@firestore-emulator/proto/dist/google/firestore/v1/query.js

Generated Firestore Protobufs For Firestore Emulator

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// generated/google/firestore/v1/query.ts
var query_exports = {};
__export(query_exports, {
  Cursor: () => Cursor,
  StructuredAggregationQuery: () => StructuredAggregationQuery,
  StructuredAggregationQueryAggregation: () => StructuredAggregationQueryAggregation,
  StructuredAggregationQueryAggregationAvg: () => StructuredAggregationQueryAggregationAvg,
  StructuredAggregationQueryAggregationCount: () => StructuredAggregationQueryAggregationCount,
  StructuredAggregationQueryAggregationSum: () => StructuredAggregationQueryAggregationSum,
  StructuredQuery: () => StructuredQuery,
  StructuredQueryCollectionSelector: () => StructuredQueryCollectionSelector,
  StructuredQueryCompositeFilter: () => StructuredQueryCompositeFilter,
  StructuredQueryCompositeFilterOperator: () => StructuredQueryCompositeFilterOperator,
  StructuredQueryDirection: () => StructuredQueryDirection,
  StructuredQueryFieldFilter: () => StructuredQueryFieldFilter,
  StructuredQueryFieldFilterOperator: () => StructuredQueryFieldFilterOperator,
  StructuredQueryFieldReference: () => StructuredQueryFieldReference,
  StructuredQueryFilter: () => StructuredQueryFilter,
  StructuredQueryFindNearest: () => StructuredQueryFindNearest,
  StructuredQueryFindNearestDistanceMeasure: () => StructuredQueryFindNearestDistanceMeasure,
  StructuredQueryOrder: () => StructuredQueryOrder,
  StructuredQueryProjection: () => StructuredQueryProjection,
  StructuredQueryUnaryFilter: () => StructuredQueryUnaryFilter,
  StructuredQueryUnaryFilterOperator: () => StructuredQueryUnaryFilterOperator
});
module.exports = __toCommonJS(query_exports);

// generated/google/protobuf/struct.ts
var pb_1 = __toESM(require("google-protobuf"));

// generated/google/protobuf/timestamp.ts
var pb_12 = __toESM(require("google-protobuf"));
var Timestamp = class _Timestamp extends pb_12.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_12.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("seconds" in data && data.seconds != void 0) {
        this.seconds = data.seconds;
      }
      if ("nanos" in data && data.nanos != void 0) {
        this.nanos = data.nanos;
      }
    }
  }
  get seconds() {
    return pb_12.Message.getFieldWithDefault(this, 1, 0);
  }
  set seconds(value) {
    pb_12.Message.setField(this, 1, value);
  }
  get nanos() {
    return pb_12.Message.getFieldWithDefault(this, 2, 0);
  }
  set nanos(value) {
    pb_12.Message.setField(this, 2, value);
  }
  static fromObject(data) {
    const message = new _Timestamp({});
    if (data.seconds != null) {
      message.seconds = data.seconds;
    }
    if (data.nanos != null) {
      message.nanos = data.nanos;
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.seconds != null) {
      data.seconds = this.seconds;
    }
    if (this.nanos != null) {
      data.nanos = this.nanos;
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_12.BinaryWriter();
    if (this.seconds != 0)
      writer.writeInt64(1, this.seconds);
    if (this.nanos != 0)
      writer.writeInt32(2, this.nanos);
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_12.BinaryReader ? bytes : new pb_12.BinaryReader(bytes), message = new _Timestamp();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.seconds = reader.readInt64();
          break;
        case 2:
          message.nanos = reader.readInt32();
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _Timestamp.deserialize(bytes);
  }
};

// generated/google/type/latlng.ts
var pb_13 = __toESM(require("google-protobuf"));
var LatLng = class _LatLng extends pb_13.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_13.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("latitude" in data && data.latitude != void 0) {
        this.latitude = data.latitude;
      }
      if ("longitude" in data && data.longitude != void 0) {
        this.longitude = data.longitude;
      }
    }
  }
  get latitude() {
    return pb_13.Message.getFieldWithDefault(this, 1, 0);
  }
  set latitude(value) {
    pb_13.Message.setField(this, 1, value);
  }
  get longitude() {
    return pb_13.Message.getFieldWithDefault(this, 2, 0);
  }
  set longitude(value) {
    pb_13.Message.setField(this, 2, value);
  }
  static fromObject(data) {
    const message = new _LatLng({});
    if (data.latitude != null) {
      message.latitude = data.latitude;
    }
    if (data.longitude != null) {
      message.longitude = data.longitude;
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.latitude != null) {
      data.latitude = this.latitude;
    }
    if (this.longitude != null) {
      data.longitude = this.longitude;
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_13.BinaryWriter();
    if (this.latitude != 0)
      writer.writeDouble(1, this.latitude);
    if (this.longitude != 0)
      writer.writeDouble(2, this.longitude);
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_13.BinaryReader ? bytes : new pb_13.BinaryReader(bytes), message = new _LatLng();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.latitude = reader.readDouble();
          break;
        case 2:
          message.longitude = reader.readDouble();
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _LatLng.deserialize(bytes);
  }
};

// generated/google/firestore/v1/document.ts
var pb_14 = __toESM(require("google-protobuf"));
var Value = class _Value extends pb_14.Message {
  #one_of_decls = [[11, 1, 2, 3, 10, 17, 18, 5, 8, 9, 6]];
  constructor(data) {
    super();
    pb_14.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("null_value" in data && data.null_value != void 0) {
        this.null_value = data.null_value;
      }
      if ("boolean_value" in data && data.boolean_value != void 0) {
        this.boolean_value = data.boolean_value;
      }
      if ("integer_value" in data && data.integer_value != void 0) {
        this.integer_value = data.integer_value;
      }
      if ("double_value" in data && data.double_value != void 0) {
        this.double_value = data.double_value;
      }
      if ("timestamp_value" in data && data.timestamp_value != void 0) {
        this.timestamp_value = data.timestamp_value;
      }
      if ("string_value" in data && data.string_value != void 0) {
        this.string_value = data.string_value;
      }
      if ("bytes_value" in data && data.bytes_value != void 0) {
        this.bytes_value = data.bytes_value;
      }
      if ("reference_value" in data && data.reference_value != void 0) {
        this.reference_value = data.reference_value;
      }
      if ("geo_point_value" in data && data.geo_point_value != void 0) {
        this.geo_point_value = data.geo_point_value;
      }
      if ("array_value" in data && data.array_value != void 0) {
        this.array_value = data.array_value;
      }
      if ("map_value" in data && data.map_value != void 0) {
        this.map_value = data.map_value;
      }
    }
  }
  get null_value() {
    return pb_14.Message.getFieldWithDefault(this, 11, 0 /* NULL_VALUE */);
  }
  set null_value(value) {
    pb_14.Message.setOneofField(this, 11, this.#one_of_decls[0], value);
  }
  get has_null_value() {
    return pb_14.Message.getField(this, 11) != null;
  }
  get boolean_value() {
    return pb_14.Message.getFieldWithDefault(this, 1, false);
  }
  set boolean_value(value) {
    pb_14.Message.setOneofField(this, 1, this.#one_of_decls[0], value);
  }
  get has_boolean_value() {
    return pb_14.Message.getField(this, 1) != null;
  }
  get integer_value() {
    return pb_14.Message.getFieldWithDefault(this, 2, 0);
  }
  set integer_value(value) {
    pb_14.Message.setOneofField(this, 2, this.#one_of_decls[0], value);
  }
  get has_integer_value() {
    return pb_14.Message.getField(this, 2) != null;
  }
  get double_value() {
    return pb_14.Message.getFieldWithDefault(this, 3, 0);
  }
  set double_value(value) {
    pb_14.Message.setOneofField(this, 3, this.#one_of_decls[0], value);
  }
  get has_double_value() {
    return pb_14.Message.getField(this, 3) != null;
  }
  get timestamp_value() {
    return pb_14.Message.getWrapperField(this, Timestamp, 10);
  }
  set timestamp_value(value) {
    pb_14.Message.setOneofWrapperField(this, 10, this.#one_of_decls[0], value);
  }
  get has_timestamp_value() {
    return pb_14.Message.getField(this, 10) != null;
  }
  get string_value() {
    return pb_14.Message.getFieldWithDefault(this, 17, "");
  }
  set string_value(value) {
    pb_14.Message.setOneofField(this, 17, this.#one_of_decls[0], value);
  }
  get has_string_value() {
    return pb_14.Message.getField(this, 17) != null;
  }
  get bytes_value() {
    return pb_14.Message.getFieldWithDefault(this, 18, new Uint8Array(0));
  }
  set bytes_value(value) {
    pb_14.Message.setOneofField(this, 18, this.#one_of_decls[0], value);
  }
  get has_bytes_value() {
    return pb_14.Message.getField(this, 18) != null;
  }
  get reference_value() {
    return pb_14.Message.getFieldWithDefault(this, 5, "");
  }
  set reference_value(value) {
    pb_14.Message.setOneofField(this, 5, this.#one_of_decls[0], value);
  }
  get has_reference_value() {
    return pb_14.Message.getField(this, 5) != null;
  }
  get geo_point_value() {
    return pb_14.Message.getWrapperField(this, LatLng, 8);
  }
  set geo_point_value(value) {
    pb_14.Message.setOneofWrapperField(this, 8, this.#one_of_decls[0], value);
  }
  get has_geo_point_value() {
    return pb_14.Message.getField(this, 8) != null;
  }
  get array_value() {
    return pb_14.Message.getWrapperField(this, ArrayValue, 9);
  }
  set array_value(value) {
    pb_14.Message.setOneofWrapperField(this, 9, this.#one_of_decls[0], value);
  }
  get has_array_value() {
    return pb_14.Message.getField(this, 9) != null;
  }
  get map_value() {
    return pb_14.Message.getWrapperField(this, MapValue, 6);
  }
  set map_value(value) {
    pb_14.Message.setOneofWrapperField(this, 6, this.#one_of_decls[0], value);
  }
  get has_map_value() {
    return pb_14.Message.getField(this, 6) != null;
  }
  get value_type() {
    const cases = {
      0: "none",
      11: "null_value",
      1: "boolean_value",
      2: "integer_value",
      3: "double_value",
      10: "timestamp_value",
      17: "string_value",
      18: "bytes_value",
      5: "reference_value",
      8: "geo_point_value",
      9: "array_value",
      6: "map_value"
    };
    return cases[pb_14.Message.computeOneofCase(this, [11, 1, 2, 3, 10, 17, 18, 5, 8, 9, 6])];
  }
  static fromObject(data) {
    const message = new _Value({});
    if (data.null_value != null) {
      message.null_value = data.null_value;
    }
    if (data.boolean_value != null) {
      message.boolean_value = data.boolean_value;
    }
    if (data.integer_value != null) {
      message.integer_value = data.integer_value;
    }
    if (data.double_value != null) {
      message.double_value = data.double_value;
    }
    if (data.timestamp_value != null) {
      message.timestamp_value = Timestamp.fromObject(data.timestamp_value);
    }
    if (data.string_value != null) {
      message.string_value = data.string_value;
    }
    if (data.bytes_value != null) {
      message.bytes_value = data.bytes_value;
    }
    if (data.reference_value != null) {
      message.reference_value = data.reference_value;
    }
    if (data.geo_point_value != null) {
      message.geo_point_value = LatLng.fromObject(data.geo_point_value);
    }
    if (data.array_value != null) {
      message.array_value = ArrayValue.fromObject(data.array_value);
    }
    if (data.map_value != null) {
      message.map_value = MapValue.fromObject(data.map_value);
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.null_value != null) {
      data.null_value = this.null_value;
    }
    if (this.boolean_value != null) {
      data.boolean_value = this.boolean_value;
    }
    if (this.integer_value != null) {
      data.integer_value = this.integer_value;
    }
    if (this.double_value != null) {
      data.double_value = this.double_value;
    }
    if (this.timestamp_value != null) {
      data.timestamp_value = this.timestamp_value.toObject();
    }
    if (this.string_value != null) {
      data.string_value = this.string_value;
    }
    if (this.bytes_value != null) {
      data.bytes_value = this.bytes_value;
    }
    if (this.reference_value != null) {
      data.reference_value = this.reference_value;
    }
    if (this.geo_point_value != null) {
      data.geo_point_value = this.geo_point_value.toObject();
    }
    if (this.array_value != null) {
      data.array_value = this.array_value.toObject();
    }
    if (this.map_value != null) {
      data.map_value = this.map_value.toObject();
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_14.BinaryWriter();
    if (this.has_null_value)
      writer.writeEnum(11, this.null_value);
    if (this.has_boolean_value)
      writer.writeBool(1, this.boolean_value);
    if (this.has_integer_value)
      writer.writeInt64(2, this.integer_value);
    if (this.has_double_value)
      writer.writeDouble(3, this.double_value);
    if (this.has_timestamp_value)
      writer.writeMessage(10, this.timestamp_value, () => this.timestamp_value.serialize(writer));
    if (this.has_string_value)
      writer.writeString(17, this.string_value);
    if (this.has_bytes_value)
      writer.writeBytes(18, this.bytes_value);
    if (this.has_reference_value)
      writer.writeString(5, this.reference_value);
    if (this.has_geo_point_value)
      writer.writeMessage(8, this.geo_point_value, () => this.geo_point_value.serialize(writer));
    if (this.has_array_value)
      writer.writeMessage(9, this.array_value, () => this.array_value.serialize(writer));
    if (this.has_map_value)
      writer.writeMessage(6, this.map_value, () => this.map_value.serialize(writer));
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_14.BinaryReader ? bytes : new pb_14.BinaryReader(bytes), message = new _Value();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 11:
          message.null_value = reader.readEnum();
          break;
        case 1:
          message.boolean_value = reader.readBool();
          break;
        case 2:
          message.integer_value = reader.readInt64();
          break;
        case 3:
          message.double_value = reader.readDouble();
          break;
        case 10:
          reader.readMessage(message.timestamp_value, () => message.timestamp_value = Timestamp.deserialize(reader));
          break;
        case 17:
          message.string_value = reader.readString();
          break;
        case 18:
          message.bytes_value = reader.readBytes();
          break;
        case 5:
          message.reference_value = reader.readString();
          break;
        case 8:
          reader.readMessage(message.geo_point_value, () => message.geo_point_value = LatLng.deserialize(reader));
          break;
        case 9:
          reader.readMessage(message.array_value, () => message.array_value = ArrayValue.deserialize(reader));
          break;
        case 6:
          reader.readMessage(message.map_value, () => message.map_value = MapValue.deserialize(reader));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _Value.deserialize(bytes);
  }
};
var ArrayValue = class _ArrayValue extends pb_14.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_14.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("values" in data && data.values != void 0) {
        this.values = data.values;
      }
    }
  }
  get values() {
    return pb_14.Message.getRepeatedWrapperField(this, Value, 1);
  }
  set values(value) {
    pb_14.Message.setRepeatedWrapperField(this, 1, value);
  }
  static fromObject(data) {
    const message = new _ArrayValue({});
    if (data.values != null) {
      message.values = data.values.map((item) => Value.fromObject(item));
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.values != null) {
      data.values = this.values.map((item) => item.toObject());
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_14.BinaryWriter();
    if (this.values.length)
      writer.writeRepeatedMessage(1, this.values, (item) => item.serialize(writer));
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_14.BinaryReader ? bytes : new pb_14.BinaryReader(bytes), message = new _ArrayValue();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          reader.readMessage(message.values, () => pb_14.Message.addToRepeatedWrapperField(message, 1, Value.deserialize(reader), Value));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _ArrayValue.deserialize(bytes);
  }
};
var MapValue = class _MapValue extends pb_14.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_14.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("fields" in data && data.fields != void 0) {
        this.fields = data.fields;
      }
    }
    if (!this.fields)
      this.fields = /* @__PURE__ */ new Map();
  }
  get fields() {
    return pb_14.Message.getField(this, 1);
  }
  set fields(value) {
    pb_14.Message.setField(this, 1, value);
  }
  static fromObject(data) {
    const message = new _MapValue({});
    if (typeof data.fields == "object") {
      message.fields = new Map(Object.entries(data.fields).map(([key, value]) => [key, Value.fromObject(value)]));
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.fields != null) {
      data.fields = Object.fromEntries(Array.from(this.fields).map(([key, value]) => [key, value.toObject()]));
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_14.BinaryWriter();
    for (const [key, value] of this.fields) {
      writer.writeMessage(1, this.fields, () => {
        writer.writeString(1, key);
        writer.writeMessage(2, value, () => value.serialize(writer));
      });
    }
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_14.BinaryReader ? bytes : new pb_14.BinaryReader(bytes), message = new _MapValue();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          reader.readMessage(message, () => pb_14.Map.deserializeBinary(message.fields, reader, reader.readString, () => {
            let value;
            reader.readMessage(message, () => value = Value.deserialize(reader));
            return value;
          }));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _MapValue.deserialize(bytes);
  }
};

// generated/google/protobuf/wrappers.ts
var pb_15 = __toESM(require("google-protobuf"));
var DoubleValue = class _DoubleValue extends pb_15.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_15.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("value" in data && data.value != void 0) {
        this.value = data.value;
      }
    }
  }
  get value() {
    return pb_15.Message.getFieldWithDefault(this, 1, 0);
  }
  set value(value) {
    pb_15.Message.setField(this, 1, value);
  }
  static fromObject(data) {
    const message = new _DoubleValue({});
    if (data.value != null) {
      message.value = data.value;
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.value != null) {
      data.value = this.value;
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_15.BinaryWriter();
    if (this.value != 0)
      writer.writeDouble(1, this.value);
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_15.BinaryReader ? bytes : new pb_15.BinaryReader(bytes), message = new _DoubleValue();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.value = reader.readDouble();
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _DoubleValue.deserialize(bytes);
  }
};
var Int64Value = class _Int64Value extends pb_15.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_15.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("value" in data && data.value != void 0) {
        this.value = data.value;
      }
    }
  }
  get value() {
    return pb_15.Message.getFieldWithDefault(this, 1, 0);
  }
  set value(value) {
    pb_15.Message.setField(this, 1, value);
  }
  static fromObject(data) {
    const message = new _Int64Value({});
    if (data.value != null) {
      message.value = data.value;
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.value != null) {
      data.value = this.value;
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_15.BinaryWriter();
    if (this.value != 0)
      writer.writeInt64(1, this.value);
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_15.BinaryReader ? bytes : new pb_15.BinaryReader(bytes), message = new _Int64Value();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.value = reader.readInt64();
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _Int64Value.deserialize(bytes);
  }
};
var Int32Value = class _Int32Value extends pb_15.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_15.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("value" in data && data.value != void 0) {
        this.value = data.value;
      }
    }
  }
  get value() {
    return pb_15.Message.getFieldWithDefault(this, 1, 0);
  }
  set value(value) {
    pb_15.Message.setField(this, 1, value);
  }
  static fromObject(data) {
    const message = new _Int32Value({});
    if (data.value != null) {
      message.value = data.value;
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.value != null) {
      data.value = this.value;
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_15.BinaryWriter();
    if (this.value != 0)
      writer.writeInt32(1, this.value);
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_15.BinaryReader ? bytes : new pb_15.BinaryReader(bytes), message = new _Int32Value();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.value = reader.readInt32();
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _Int32Value.deserialize(bytes);
  }
};

// generated/google/firestore/v1/query.ts
var pb_16 = __toESM(require("google-protobuf"));
var StructuredQuery = class _StructuredQuery extends pb_16.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_16.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2, 4], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("select" in data && data.select != void 0) {
        this.select = data.select;
      }
      if ("from" in data && data.from != void 0) {
        this.from = data.from;
      }
      if ("where" in data && data.where != void 0) {
        this.where = data.where;
      }
      if ("order_by" in data && data.order_by != void 0) {
        this.order_by = data.order_by;
      }
      if ("start_at" in data && data.start_at != void 0) {
        this.start_at = data.start_at;
      }
      if ("end_at" in data && data.end_at != void 0) {
        this.end_at = data.end_at;
      }
      if ("offset" in data && data.offset != void 0) {
        this.offset = data.offset;
      }
      if ("limit" in data && data.limit != void 0) {
        this.limit = data.limit;
      }
      if ("find_nearest" in data && data.find_nearest != void 0) {
        this.find_nearest = data.find_nearest;
      }
    }
  }
  get select() {
    return pb_16.Message.getWrapperField(this, StructuredQueryProjection, 1);
  }
  set select(value) {
    pb_16.Message.setWrapperField(this, 1, value);
  }
  get has_select() {
    return pb_16.Message.getField(this, 1) != null;
  }
  get from() {
    return pb_16.Message.getRepeatedWrapperField(this, StructuredQueryCollectionSelector, 2);
  }
  set from(value) {
    pb_16.Message.setRepeatedWrapperField(this, 2, value);
  }
  get where() {
    return pb_16.Message.getWrapperField(this, StructuredQueryFilter, 3);
  }
  set where(value) {
    pb_16.Message.setWrapperField(this, 3, value);
  }
  get has_where() {
    return pb_16.Message.getField(this, 3) != null;
  }
  get order_by() {
    return pb_16.Message.getRepeatedWrapperField(this, StructuredQueryOrder, 4);
  }
  set order_by(value) {
    pb_16.Message.setRepeatedWrapperField(this, 4, value);
  }
  get start_at() {
    return pb_16.Message.getWrapperField(this, Cursor, 7);
  }
  set start_at(value) {
    pb_16.Message.setWrapperField(this, 7, value);
  }
  get has_start_at() {
    return pb_16.Message.getField(this, 7) != null;
  }
  get end_at() {
    return pb_16.Message.getWrapperField(this, Cursor, 8);
  }
  set end_at(value) {
    pb_16.Message.setWrapperField(this, 8, value);
  }
  get has_end_at() {
    return pb_16.Message.getField(this, 8) != null;
  }
  get offset() {
    return pb_16.Message.getFieldWithDefault(this, 6, 0);
  }
  set offset(value) {
    pb_16.Message.setField(this, 6, value);
  }
  get limit() {
    return pb_16.Message.getWrapperField(this, Int32Value, 5);
  }
  set limit(value) {
    pb_16.Message.setWrapperField(this, 5, value);
  }
  get has_limit() {
    return pb_16.Message.getField(this, 5) != null;
  }
  get find_nearest() {
    return pb_16.Message.getWrapperField(this, StructuredQueryFindNearest, 9);
  }
  set find_nearest(value) {
    pb_16.Message.setWrapperField(this, 9, value);
  }
  get has_find_nearest() {
    return pb_16.Message.getField(this, 9) != null;
  }
  static fromObject(data) {
    const message = new _StructuredQuery({});
    if (data.select != null) {
      message.select = StructuredQueryProjection.fromObject(data.select);
    }
    if (data.from != null) {
      message.from = data.from.map((item) => StructuredQueryCollectionSelector.fromObject(item));
    }
    if (data.where != null) {
      message.where = StructuredQueryFilter.fromObject(data.where);
    }
    if (data.order_by != null) {
      message.order_by = data.order_by.map((item) => StructuredQueryOrder.fromObject(item));
    }
    if (data.start_at != null) {
      message.start_at = Cursor.fromObject(data.start_at);
    }
    if (data.end_at != null) {
      message.end_at = Cursor.fromObject(data.end_at);
    }
    if (data.offset != null) {
      message.offset = data.offset;
    }
    if (data.limit != null) {
      message.limit = Int32Value.fromObject(data.limit);
    }
    if (data.find_nearest != null) {
      message.find_nearest = StructuredQueryFindNearest.fromObject(data.find_nearest);
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.select != null) {
      data.select = this.select.toObject();
    }
    if (this.from != null) {
      data.from = this.from.map((item) => item.toObject());
    }
    if (this.where != null) {
      data.where = this.where.toObject();
    }
    if (this.order_by != null) {
      data.order_by = this.order_by.map((item) => item.toObject());
    }
    if (this.start_at != null) {
      data.start_at = this.start_at.toObject();
    }
    if (this.end_at != null) {
      data.end_at = this.end_at.toObject();
    }
    if (this.offset != null) {
      data.offset = this.offset;
    }
    if (this.limit != null) {
      data.limit = this.limit.toObject();
    }
    if (this.find_nearest != null) {
      data.find_nearest = this.find_nearest.toObject();
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_16.BinaryWriter();
    if (this.has_select)
      writer.writeMessage(1, this.select, () => this.select.serialize(writer));
    if (this.from.length)
      writer.writeRepeatedMessage(2, this.from, (item) => item.serialize(writer));
    if (this.has_where)
      writer.writeMessage(3, this.where, () => this.where.serialize(writer));
    if (this.order_by.length)
      writer.writeRepeatedMessage(4, this.order_by, (item) => item.serialize(writer));
    if (this.has_start_at)
      writer.writeMessage(7, this.start_at, () => this.start_at.serialize(writer));
    if (this.has_end_at)
      writer.writeMessage(8, this.end_at, () => this.end_at.serialize(writer));
    if (this.offset != 0)
      writer.writeInt32(6, this.offset);
    if (this.has_limit)
      writer.writeMessage(5, this.limit, () => this.limit.serialize(writer));
    if (this.has_find_nearest)
      writer.writeMessage(9, this.find_nearest, () => this.find_nearest.serialize(writer));
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_16.BinaryReader ? bytes : new pb_16.BinaryReader(bytes), message = new _StructuredQuery();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          reader.readMessage(message.select, () => message.select = StructuredQueryProjection.deserialize(reader));
          break;
        case 2:
          reader.readMessage(message.from, () => pb_16.Message.addToRepeatedWrapperField(message, 2, StructuredQueryCollectionSelector.deserialize(reader), StructuredQueryCollectionSelector));
          break;
        case 3:
          reader.readMessage(message.where, () => message.where = StructuredQueryFilter.deserialize(reader));
          break;
        case 4:
          reader.readMessage(message.order_by, () => pb_16.Message.addToRepeatedWrapperField(message, 4, StructuredQueryOrder.deserialize(reader), StructuredQueryOrder));
          break;
        case 7:
          reader.readMessage(message.start_at, () => message.start_at = Cursor.deserialize(reader));
          break;
        case 8:
          reader.readMessage(message.end_at, () => message.end_at = Cursor.deserialize(reader));
          break;
        case 6:
          message.offset = reader.readInt32();
          break;
        case 5:
          reader.readMessage(message.limit, () => message.limit = Int32Value.deserialize(reader));
          break;
        case 9:
          reader.readMessage(message.find_nearest, () => message.find_nearest = StructuredQueryFindNearest.deserialize(reader));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _StructuredQuery.deserialize(bytes);
  }
};
var StructuredQueryDirection = /* @__PURE__ */ ((StructuredQueryDirection2) => {
  StructuredQueryDirection2[StructuredQueryDirection2["DIRECTION_UNSPECIFIED"] = 0] = "DIRECTION_UNSPECIFIED";
  StructuredQueryDirection2[StructuredQueryDirection2["ASCENDING"] = 1] = "ASCENDING";
  StructuredQueryDirection2[StructuredQueryDirection2["DESCENDING"] = 2] = "DESCENDING";
  return StructuredQueryDirection2;
})(StructuredQueryDirection || {});
var StructuredQueryCollectionSelector = class _StructuredQueryCollectionSelector extends pb_16.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_16.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("collection_id" in data && data.collection_id != void 0) {
        this.collection_id = data.collection_id;
      }
      if ("all_descendants" in data && data.all_descendants != void 0) {
        this.all_descendants = data.all_descendants;
      }
    }
  }
  get collection_id() {
    return pb_16.Message.getFieldWithDefault(this, 2, "");
  }
  set collection_id(value) {
    pb_16.Message.setField(this, 2, value);
  }
  get all_descendants() {
    return pb_16.Message.getFieldWithDefault(this, 3, false);
  }
  set all_descendants(value) {
    pb_16.Message.setField(this, 3, value);
  }
  static fromObject(data) {
    const message = new _StructuredQueryCollectionSelector({});
    if (data.collection_id != null) {
      message.collection_id = data.collection_id;
    }
    if (data.all_descendants != null) {
      message.all_descendants = data.all_descendants;
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.collection_id != null) {
      data.collection_id = this.collection_id;
    }
    if (this.all_descendants != null) {
      data.all_descendants = this.all_descendants;
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_16.BinaryWriter();
    if (this.collection_id.length)
      writer.writeString(2, this.collection_id);
    if (this.all_descendants != false)
      writer.writeBool(3, this.all_descendants);
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_16.BinaryReader ? bytes : new pb_16.BinaryReader(bytes), message = new _StructuredQueryCollectionSelector();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 2:
          message.collection_id = reader.readString();
          break;
        case 3:
          message.all_descendants = reader.readBool();
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _StructuredQueryCollectionSelector.deserialize(bytes);
  }
};
var StructuredQueryFilter = class _StructuredQueryFilter extends pb_16.Message {
  #one_of_decls = [[1, 2, 3]];
  constructor(data) {
    super();
    pb_16.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("composite_filter" in data && data.composite_filter != void 0) {
        this.composite_filter = data.composite_filter;
      }
      if ("field_filter" in data && data.field_filter != void 0) {
        this.field_filter = data.field_filter;
      }
      if ("unary_filter" in data && data.unary_filter != void 0) {
        this.unary_filter = data.unary_filter;
      }
    }
  }
  get composite_filter() {
    return pb_16.Message.getWrapperField(this, StructuredQueryCompositeFilter, 1);
  }
  set composite_filter(value) {
    pb_16.Message.setOneofWrapperField(this, 1, this.#one_of_decls[0], value);
  }
  get has_composite_filter() {
    return pb_16.Message.getField(this, 1) != null;
  }
  get field_filter() {
    return pb_16.Message.getWrapperField(this, StructuredQueryFieldFilter, 2);
  }
  set field_filter(value) {
    pb_16.Message.setOneofWrapperField(this, 2, this.#one_of_decls[0], value);
  }
  get has_field_filter() {
    return pb_16.Message.getField(this, 2) != null;
  }
  get unary_filter() {
    return pb_16.Message.getWrapperField(this, StructuredQueryUnaryFilter, 3);
  }
  set unary_filter(value) {
    pb_16.Message.setOneofWrapperField(this, 3, this.#one_of_decls[0], value);
  }
  get has_unary_filter() {
    return pb_16.Message.getField(this, 3) != null;
  }
  get filter_type() {
    const cases = {
      0: "none",
      1: "composite_filter",
      2: "field_filter",
      3: "unary_filter"
    };
    return cases[pb_16.Message.computeOneofCase(this, [1, 2, 3])];
  }
  static fromObject(data) {
    const message = new _StructuredQueryFilter({});
    if (data.composite_filter != null) {
      message.composite_filter = StructuredQueryCompositeFilter.fromObject(data.composite_filter);
    }
    if (data.field_filter != null) {
      message.field_filter = StructuredQueryFieldFilter.fromObject(data.field_filter);
    }
    if (data.unary_filter != null) {
      message.unary_filter = StructuredQueryUnaryFilter.fromObject(data.unary_filter);
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.composite_filter != null) {
      data.composite_filter = this.composite_filter.toObject();
    }
    if (this.field_filter != null) {
      data.field_filter = this.field_filter.toObject();
    }
    if (this.unary_filter != null) {
      data.unary_filter = this.unary_filter.toObject();
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_16.BinaryWriter();
    if (this.has_composite_filter)
      writer.writeMessage(1, this.composite_filter, () => this.composite_filter.serialize(writer));
    if (this.has_field_filter)
      writer.writeMessage(2, this.field_filter, () => this.field_filter.serialize(writer));
    if (this.has_unary_filter)
      writer.writeMessage(3, this.unary_filter, () => this.unary_filter.serialize(writer));
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_16.BinaryReader ? bytes : new pb_16.BinaryReader(bytes), message = new _StructuredQueryFilter();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          reader.readMessage(message.composite_filter, () => message.composite_filter = StructuredQueryCompositeFilter.deserialize(reader));
          break;
        case 2:
          reader.readMessage(message.field_filter, () => message.field_filter = StructuredQueryFieldFilter.deserialize(reader));
          break;
        case 3:
          reader.readMessage(message.unary_filter, () => message.unary_filter = StructuredQueryUnaryFilter.deserialize(reader));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _StructuredQueryFilter.deserialize(bytes);
  }
};
var StructuredQueryCompositeFilter = class _StructuredQueryCompositeFilter extends pb_16.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_16.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("op" in data && data.op != void 0) {
        this.op = data.op;
      }
      if ("filters" in data && data.filters != void 0) {
        this.filters = data.filters;
      }
    }
  }
  get op() {
    return pb_16.Message.getFieldWithDefault(this, 1, 0 /* OPERATOR_UNSPECIFIED */);
  }
  set op(value) {
    pb_16.Message.setField(this, 1, value);
  }
  get filters() {
    return pb_16.Message.getRepeatedWrapperField(this, StructuredQueryFilter, 2);
  }
  set filters(value) {
    pb_16.Message.setRepeatedWrapperField(this, 2, value);
  }
  static fromObject(data) {
    const message = new _StructuredQueryCompositeFilter({});
    if (data.op != null) {
      message.op = data.op;
    }
    if (data.filters != null) {
      message.filters = data.filters.map((item) => StructuredQueryFilter.fromObject(item));
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.op != null) {
      data.op = this.op;
    }
    if (this.filters != null) {
      data.filters = this.filters.map((item) => item.toObject());
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_16.BinaryWriter();
    if (this.op != 0 /* OPERATOR_UNSPECIFIED */)
      writer.writeEnum(1, this.op);
    if (this.filters.length)
      writer.writeRepeatedMessage(2, this.filters, (item) => item.serialize(writer));
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_16.BinaryReader ? bytes : new pb_16.BinaryReader(bytes), message = new _StructuredQueryCompositeFilter();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.op = reader.readEnum();
          break;
        case 2:
          reader.readMessage(message.filters, () => pb_16.Message.addToRepeatedWrapperField(message, 2, StructuredQueryFilter.deserialize(reader), StructuredQueryFilter));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _StructuredQueryCompositeFilter.deserialize(bytes);
  }
};
var StructuredQueryCompositeFilterOperator = /* @__PURE__ */ ((StructuredQueryCompositeFilterOperator2) => {
  StructuredQueryCompositeFilterOperator2[StructuredQueryCompositeFilterOperator2["OPERATOR_UNSPECIFIED"] = 0] = "OPERATOR_UNSPECIFIED";
  StructuredQueryCompositeFilterOperator2[StructuredQueryCompositeFilterOperator2["AND"] = 1] = "AND";
  StructuredQueryCompositeFilterOperator2[StructuredQueryCompositeFilterOperator2["OR"] = 2] = "OR";
  return StructuredQueryCompositeFilterOperator2;
})(StructuredQueryCompositeFilterOperator || {});
var StructuredQueryFieldFilter = class _StructuredQueryFieldFilter extends pb_16.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_16.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("field" in data && data.field != void 0) {
        this.field = data.field;
      }
      if ("op" in data && data.op != void 0) {
        this.op = data.op;
      }
      if ("value" in data && data.value != void 0) {
        this.value = data.value;
      }
    }
  }
  get field() {
    return pb_16.Message.getWrapperField(this, StructuredQueryFieldReference, 1);
  }
  set field(value) {
    pb_16.Message.setWrapperField(this, 1, value);
  }
  get has_field() {
    return pb_16.Message.getField(this, 1) != null;
  }
  get op() {
    return pb_16.Message.getFieldWithDefault(this, 2, 0 /* OPERATOR_UNSPECIFIED */);
  }
  set op(value) {
    pb_16.Message.setField(this, 2, value);
  }
  get value() {
    return pb_16.Message.getWrapperField(this, Value, 3);
  }
  set value(value) {
    pb_16.Message.setWrapperField(this, 3, value);
  }
  get has_value() {
    return pb_16.Message.getField(this, 3) != null;
  }
  static fromObject(data) {
    const message = new _StructuredQueryFieldFilter({});
    if (data.field != null) {
      message.field = StructuredQueryFieldReference.fromObject(data.field);
    }
    if (data.op != null) {
      message.op = data.op;
    }
    if (data.value != null) {
      message.value = Value.fromObject(data.value);
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.field != null) {
      data.field = this.field.toObject();
    }
    if (this.op != null) {
      data.op = this.op;
    }
    if (this.value != null) {
      data.value = this.value.toObject();
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_16.BinaryWriter();
    if (this.has_field)
      writer.writeMessage(1, this.field, () => this.field.serialize(writer));
    if (this.op != 0 /* OPERATOR_UNSPECIFIED */)
      writer.writeEnum(2, this.op);
    if (this.has_value)
      writer.writeMessage(3, this.value, () => this.value.serialize(writer));
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_16.BinaryReader ? bytes : new pb_16.BinaryReader(bytes), message = new _StructuredQueryFieldFilter();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          reader.readMessage(message.field, () => message.field = StructuredQueryFieldReference.deserialize(reader));
          break;
        case 2:
          message.op = reader.readEnum();
          break;
        case 3:
          reader.readMessage(message.value, () => message.value = Value.deserialize(reader));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _StructuredQueryFieldFilter.deserialize(bytes);
  }
};
var StructuredQueryFieldFilterOperator = /* @__PURE__ */ ((StructuredQueryFieldFilterOperator2) => {
  StructuredQueryFieldFilterOperator2[StructuredQueryFieldFilterOperator2["OPERATOR_UNSPECIFIED"] = 0] = "OPERATOR_UNSPECIFIED";
  StructuredQueryFieldFilterOperator2[StructuredQueryFieldFilterOperator2["LESS_THAN"] = 1] = "LESS_THAN";
  StructuredQueryFieldFilterOperator2[StructuredQueryFieldFilterOperator2["LESS_THAN_OR_EQUAL"] = 2] = "LESS_THAN_OR_EQUAL";
  StructuredQueryFieldFilterOperator2[StructuredQueryFieldFilterOperator2["GREATER_THAN"] = 3] = "GREATER_THAN";
  StructuredQueryFieldFilterOperator2[StructuredQueryFieldFilterOperator2["GREATER_THAN_OR_EQUAL"] = 4] = "GREATER_THAN_OR_EQUAL";
  StructuredQueryFieldFilterOperator2[StructuredQueryFieldFilterOperator2["EQUAL"] = 5] = "EQUAL";
  StructuredQueryFieldFilterOperator2[StructuredQueryFieldFilterOperator2["NOT_EQUAL"] = 6] = "NOT_EQUAL";
  StructuredQueryFieldFilterOperator2[StructuredQueryFieldFilterOperator2["ARRAY_CONTAINS"] = 7] = "ARRAY_CONTAINS";
  StructuredQueryFieldFilterOperator2[StructuredQueryFieldFilterOperator2["IN"] = 8] = "IN";
  StructuredQueryFieldFilterOperator2[StructuredQueryFieldFilterOperator2["ARRAY_CONTAINS_ANY"] = 9] = "ARRAY_CONTAINS_ANY";
  StructuredQueryFieldFilterOperator2[StructuredQueryFieldFilterOperator2["NOT_IN"] = 10] = "NOT_IN";
  return StructuredQueryFieldFilterOperator2;
})(StructuredQueryFieldFilterOperator || {});
var StructuredQueryUnaryFilter = class _StructuredQueryUnaryFilter extends pb_16.Message {
  #one_of_decls = [[2]];
  construc