@firestore-emulator/proto/dist/google/firestore/v1/firestore.mjs

Generated Firestore Protobufs For Firestore Emulator

// generated/google/protobuf/struct.ts
import * as pb_1 from "google-protobuf";
var Struct = class _Struct extends pb_1.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_1.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_1.Message.getField(this, 1);
  }
  set fields(value) {
    pb_1.Message.setField(this, 1, value);
  }
  static fromObject(data) {
    const message = new _Struct({});
    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_1.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_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new _Struct();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          reader.readMessage(message, () => pb_1.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 _Struct.deserialize(bytes);
  }
};
var Value = class _Value extends pb_1.Message {
  #one_of_decls = [[1, 2, 3, 4, 5, 6]];
  constructor(data) {
    super();
    pb_1.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 ("number_value" in data && data.number_value != void 0) {
        this.number_value = data.number_value;
      }
      if ("string_value" in data && data.string_value != void 0) {
        this.string_value = data.string_value;
      }
      if ("bool_value" in data && data.bool_value != void 0) {
        this.bool_value = data.bool_value;
      }
      if ("struct_value" in data && data.struct_value != void 0) {
        this.struct_value = data.struct_value;
      }
      if ("list_value" in data && data.list_value != void 0) {
        this.list_value = data.list_value;
      }
    }
  }
  get null_value() {
    return pb_1.Message.getFieldWithDefault(this, 1, 0 /* NULL_VALUE */);
  }
  set null_value(value) {
    pb_1.Message.setOneofField(this, 1, this.#one_of_decls[0], value);
  }
  get has_null_value() {
    return pb_1.Message.getField(this, 1) != null;
  }
  get number_value() {
    return pb_1.Message.getFieldWithDefault(this, 2, 0);
  }
  set number_value(value) {
    pb_1.Message.setOneofField(this, 2, this.#one_of_decls[0], value);
  }
  get has_number_value() {
    return pb_1.Message.getField(this, 2) != null;
  }
  get string_value() {
    return pb_1.Message.getFieldWithDefault(this, 3, "");
  }
  set string_value(value) {
    pb_1.Message.setOneofField(this, 3, this.#one_of_decls[0], value);
  }
  get has_string_value() {
    return pb_1.Message.getField(this, 3) != null;
  }
  get bool_value() {
    return pb_1.Message.getFieldWithDefault(this, 4, false);
  }
  set bool_value(value) {
    pb_1.Message.setOneofField(this, 4, this.#one_of_decls[0], value);
  }
  get has_bool_value() {
    return pb_1.Message.getField(this, 4) != null;
  }
  get struct_value() {
    return pb_1.Message.getWrapperField(this, Struct, 5);
  }
  set struct_value(value) {
    pb_1.Message.setOneofWrapperField(this, 5, this.#one_of_decls[0], value);
  }
  get has_struct_value() {
    return pb_1.Message.getField(this, 5) != null;
  }
  get list_value() {
    return pb_1.Message.getWrapperField(this, ListValue, 6);
  }
  set list_value(value) {
    pb_1.Message.setOneofWrapperField(this, 6, this.#one_of_decls[0], value);
  }
  get has_list_value() {
    return pb_1.Message.getField(this, 6) != null;
  }
  get kind() {
    const cases = {
      0: "none",
      1: "null_value",
      2: "number_value",
      3: "string_value",
      4: "bool_value",
      5: "struct_value",
      6: "list_value"
    };
    return cases[pb_1.Message.computeOneofCase(this, [1, 2, 3, 4, 5, 6])];
  }
  static fromObject(data) {
    const message = new _Value({});
    if (data.null_value != null) {
      message.null_value = data.null_value;
    }
    if (data.number_value != null) {
      message.number_value = data.number_value;
    }
    if (data.string_value != null) {
      message.string_value = data.string_value;
    }
    if (data.bool_value != null) {
      message.bool_value = data.bool_value;
    }
    if (data.struct_value != null) {
      message.struct_value = Struct.fromObject(data.struct_value);
    }
    if (data.list_value != null) {
      message.list_value = ListValue.fromObject(data.list_value);
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.null_value != null) {
      data.null_value = this.null_value;
    }
    if (this.number_value != null) {
      data.number_value = this.number_value;
    }
    if (this.string_value != null) {
      data.string_value = this.string_value;
    }
    if (this.bool_value != null) {
      data.bool_value = this.bool_value;
    }
    if (this.struct_value != null) {
      data.struct_value = this.struct_value.toObject();
    }
    if (this.list_value != null) {
      data.list_value = this.list_value.toObject();
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_1.BinaryWriter();
    if (this.has_null_value)
      writer.writeEnum(1, this.null_value);
    if (this.has_number_value)
      writer.writeDouble(2, this.number_value);
    if (this.has_string_value)
      writer.writeString(3, this.string_value);
    if (this.has_bool_value)
      writer.writeBool(4, this.bool_value);
    if (this.has_struct_value)
      writer.writeMessage(5, this.struct_value, () => this.struct_value.serialize(writer));
    if (this.has_list_value)
      writer.writeMessage(6, this.list_value, () => this.list_value.serialize(writer));
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new _Value();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.null_value = reader.readEnum();
          break;
        case 2:
          message.number_value = reader.readDouble();
          break;
        case 3:
          message.string_value = reader.readString();
          break;
        case 4:
          message.bool_value = reader.readBool();
          break;
        case 5:
          reader.readMessage(message.struct_value, () => message.struct_value = Struct.deserialize(reader));
          break;
        case 6:
          reader.readMessage(message.list_value, () => message.list_value = ListValue.deserialize(reader));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _Value.deserialize(bytes);
  }
};
var ListValue = class _ListValue extends pb_1.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_1.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_1.Message.getRepeatedWrapperField(this, Value, 1);
  }
  set values(value) {
    pb_1.Message.setRepeatedWrapperField(this, 1, value);
  }
  static fromObject(data) {
    const message = new _ListValue({});
    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_1.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_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new _ListValue();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          reader.readMessage(message.values, () => pb_1.Message.addToRepeatedWrapperField(message, 1, Value.deserialize(reader), Value));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _ListValue.deserialize(bytes);
  }
};

// generated/google/protobuf/timestamp.ts
import * as pb_12 from "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
import * as pb_13 from "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
import * as pb_14 from "google-protobuf";
var Document = class _Document 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 ("name" in data && data.name != void 0) {
        this.name = data.name;
      }
      if ("fields" in data && data.fields != void 0) {
        this.fields = data.fields;
      }
      if ("create_time" in data && data.create_time != void 0) {
        this.create_time = data.create_time;
      }
      if ("update_time" in data && data.update_time != void 0) {
        this.update_time = data.update_time;
      }
    }
    if (!this.fields)
      this.fields = /* @__PURE__ */ new Map();
  }
  get name() {
    return pb_14.Message.getFieldWithDefault(this, 1, "");
  }
  set name(value) {
    pb_14.Message.setField(this, 1, value);
  }
  get fields() {
    return pb_14.Message.getField(this, 2);
  }
  set fields(value) {
    pb_14.Message.setField(this, 2, value);
  }
  get create_time() {
    return pb_14.Message.getWrapperField(this, Timestamp, 3);
  }
  set create_time(value) {
    pb_14.Message.setWrapperField(this, 3, value);
  }
  get has_create_time() {
    return pb_14.Message.getField(this, 3) != null;
  }
  get update_time() {
    return pb_14.Message.getWrapperField(this, Timestamp, 4);
  }
  set update_time(value) {
    pb_14.Message.setWrapperField(this, 4, value);
  }
  get has_update_time() {
    return pb_14.Message.getField(this, 4) != null;
  }
  static fromObject(data) {
    const message = new _Document({});
    if (data.name != null) {
      message.name = data.name;
    }
    if (typeof data.fields == "object") {
      message.fields = new Map(Object.entries(data.fields).map(([key, value]) => [key, Value2.fromObject(value)]));
    }
    if (data.create_time != null) {
      message.create_time = Timestamp.fromObject(data.create_time);
    }
    if (data.update_time != null) {
      message.update_time = Timestamp.fromObject(data.update_time);
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.name != null) {
      data.name = this.name;
    }
    if (this.fields != null) {
      data.fields = Object.fromEntries(Array.from(this.fields).map(([key, value]) => [key, value.toObject()]));
    }
    if (this.create_time != null) {
      data.create_time = this.create_time.toObject();
    }
    if (this.update_time != null) {
      data.update_time = this.update_time.toObject();
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_14.BinaryWriter();
    if (this.name.length)
      writer.writeString(1, this.name);
    for (const [key, value] of this.fields) {
      writer.writeMessage(2, this.fields, () => {
        writer.writeString(1, key);
        writer.writeMessage(2, value, () => value.serialize(writer));
      });
    }
    if (this.has_create_time)
      writer.writeMessage(3, this.create_time, () => this.create_time.serialize(writer));
    if (this.has_update_time)
      writer.writeMessage(4, this.update_time, () => this.update_time.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 _Document();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.name = reader.readString();
          break;
        case 2:
          reader.readMessage(message, () => pb_14.Map.deserializeBinary(message.fields, reader, reader.readString, () => {
            let value;
            reader.readMessage(message, () => value = Value2.deserialize(reader));
            return value;
          }));
          break;
        case 3:
          reader.readMessage(message.create_time, () => message.create_time = Timestamp.deserialize(reader));
          break;
        case 4:
          reader.readMessage(message.update_time, () => message.update_time = Timestamp.deserialize(reader));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _Document.deserialize(bytes);
  }
};
var Value2 = 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, Value2, 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) => Value2.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, Value2.deserialize(reader), Value2));
          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, Value2.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 = Value2.deserialize(reader));
            return value;
          }));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _MapValue.deserialize(bytes);
  }
};

// generated/google/firestore/v1/aggregation_result.ts
import * as pb_15 from "google-protobuf";
var AggregationResult = class _AggregationResult 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 ("aggregate_fields" in data && data.aggregate_fields != void 0) {
        this.aggregate_fields = data.aggregate_fields;
      }
    }
    if (!this.aggregate_fields)
      this.aggregate_fields = /* @__PURE__ */ new Map();
  }
  get aggregate_fields() {
    return pb_15.Message.getField(this, 2);
  }
  set aggregate_fields(value) {
    pb_15.Message.setField(this, 2, value);
  }
  static fromObject(data) {
    const message = new _AggregationResult({});
    if (typeof data.aggregate_fields == "object") {
      message.aggregate_fields = new Map(Object.entries(data.aggregate_fields).map(([key, value]) => [key, Value2.fromObject(value)]));
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.aggregate_fields != null) {
      data.aggregate_fields = Object.fromEntries(Array.from(this.aggregate_fields).map(([key, value]) => [key, value.toObject()]));
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_15.BinaryWriter();
    for (const [key, value] of this.aggregate_fields) {
      writer.writeMessage(2, this.aggregate_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_15.BinaryReader ? bytes : new pb_15.BinaryReader(bytes), message = new _AggregationResult();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 2:
          reader.readMessage(message, () => pb_15.Map.deserializeBinary(message.aggregate_fields, reader, reader.readString, () => {
            let value;
            reader.readMessage(message, () => value = Value2.deserialize(reader));
            return value;
          }));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _AggregationResult.deserialize(bytes);
  }
};

// generated/google/firestore/v1/common.ts
import * as pb_16 from "google-protobuf";
var DocumentMask = class _DocumentMask extends pb_16.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_16.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("field_paths" in data && data.field_paths != void 0) {
        this.field_paths = data.field_paths;
      }
    }
  }
  get field_paths() {
    return pb_16.Message.getFieldWithDefault(this, 1, []);
  }
  set field_paths(value) {
    pb_16.Message.setField(this, 1, value);
  }
  static fromObject(data) {
    const message = new _DocumentMask({});
    if (data.field_paths != null) {
      message.field_paths = data.field_paths;
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.field_paths != null) {
      data.field_paths = this.field_paths;
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_16.BinaryWriter();
    if (this.field_paths.length)
      writer.writeRepeatedString(1, this.field_paths);
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_16.BinaryReader ? bytes : new pb_16.BinaryReader(bytes), message = new _DocumentMask();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          pb_16.Message.addToRepeatedField(message, 1, reader.readString());
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _DocumentMask.deserialize(bytes);
  }
};
var Precondition = class _Precondition extends pb_16.Message {
  #one_of_decls = [[1, 2]];
  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 ("exists" in data && data.exists != void 0) {
        this.exists = data.exists;
      }
      if ("update_time" in data && data.update_time != void 0) {
        this.update_time = data.update_time;
      }
    }
  }
  get exists() {
    return pb_16.Message.getFieldWithDefault(this, 1, false);
  }
  set exists(value) {
    pb_16.Message.setOneofField(this, 1, this.#one_of_decls[0], value);
  }
  get has_exists() {
    return pb_16.Message.getField(this, 1) != null;
  }
  get update_time() {
    return pb_16.Message.getWrapperField(this, Timestamp, 2);
  }
  set update_time(value) {
    pb_16.Message.setOneofWrapperField(this, 2, this.#one_of_decls[0], value);
  }
  get has_update_time() {
    return pb_16.Message.getField(this, 2) != null;
  }
  get condition_type() {
    const cases = {
      0: "none",
      1: "exists",
      2: "update_time"
    };
    return cases[pb_16.Message.computeOneofCase(this, [1, 2])];
  }
  static fromObject(data) {
    const message = new _Precondition({});
    if (data.exists != null) {
      message.exists = data.exists;
    }
    if (data.update_time != null) {
      message.update_time = Timestamp.fromObject(data.update_time);
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.exists != null) {
      data.exists = this.exists;
    }
    if (this.update_time != null) {
      data.update_time = this.update_time.toObject();
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_16.BinaryWriter();
    if (this.has_exists)
      writer.writeBool(1, this.exists);
    if (this.has_update_time)
      writer.writeMessage(2, this.update_time, () => this.update_time.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 _Precondition();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.exists = reader.readBool();
          break;
        case 2:
          reader.readMessage(message.update_time, () => message.update_time = Timestamp.deserialize(reader));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _Precondition.deserialize(bytes);
  }
};
var TransactionOptions = class _TransactionOptions extends pb_16.Message {
  #one_of_decls = [[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 ("read_only" in data && data.read_only != void 0) {
        this.read_only = data.read_only;
      }
      if ("read_write" in data && data.read_write != void 0) {
        this.read_write = data.read_write;
      }
    }
  }
  get read_only() {
    return pb_16.Message.getWrapperField(this, TransactionOptionsReadOnly, 2);
  }
  set read_only(value) {
    pb_16.Message.setOneofWrapperField(this, 2, this.#one_of_decls[0], value);
  }
  get has_read_only() {
    return pb_16.Message.getField(this, 2) != null;
  }
  get read_write() {
    return pb_16.Message.getWrapperField(this, TransactionOptionsReadWrite, 3);
  }
  set read_write(value) {
    pb_16.Message.setOneofWrapperField(this, 3, this.#one_of_decls[0], value);
  }
  get has_read_write() {
    return pb_16.Message.getField(this, 3) != null;
  }
  get mode() {
    const cases = {
      0: "none",
      2: "read_only",
      3: "read_write"
    };
    return cases[pb_16.Message.computeOneofCase(this, [2, 3])];
  }
  static fromObject(data) {
    const message = new _TransactionOptions({});
    if (data.read_only != null) {
      message.read_only = TransactionOptionsReadOnly.fromObject(data.read_only);
    }
    if (data.read_write != null) {
      message.read_write = TransactionOptionsReadWrite.fromObject(data.read_write);
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.read_only != null) {
      data.read_only = this.read_only.toObject();
    }
    if (this.read_write != null) {
      data.read_write = this.read_write.toObject();
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_16.BinaryWriter();
    if (this.has_read_only)
      writer.writeMessage(2, this.read_only, () => this.read_only.serialize(writer));
    if (this.has_read_write)
      writer.writeMessage(3, this.read_write, () => this.read_write.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 _TransactionOptions();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 2:
          reader.readMessage(message.read_only, () => message.read_only = TransactionOptionsReadOnly.deserialize(reader));
          break;
        case 3:
          reader.readMessage(message.read_write, () => message.read_write = TransactionOptionsReadWrite.deserialize(reader));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _TransactionOptions.deserialize(bytes);
  }
};
var TransactionOptionsReadWrite = class _TransactionOptionsReadWrite 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 ("retry_transaction" in data && data.retry_transaction != void 0) {
        this.retry_transaction = data.retry_transaction;
      }
    }
  }
  get retry_transaction() {
    return pb_16.Message.getFieldWithDefault(this, 1, new Uint8Array(0));
  }
  set retry_transaction(value) {
    pb_16.Message.setField(this, 1, value);
  }
  static fromObject(data) {
    const message = new _TransactionOptionsReadWrite({});
    if (data.retry_transaction != null) {
      message.retry_transaction = data.retry_transaction;
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.retry_transaction != null) {
      data.retry_transaction = this.retry_transaction;
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_16.BinaryWriter();
    if (this.retry_transaction.length)
      writer.writeBytes(1, this.retry_transaction);
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_16.BinaryReader ? bytes : new pb_16.BinaryReader(bytes), message = new _TransactionOptionsReadWrite();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.retry_transaction = reader.readBytes();
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _TransactionOptionsReadWrite.deserialize(bytes);
  }
};
var TransactionOptionsReadOnly = class _TransactionOptionsReadOnly extends pb_16.Message {
  #one_of_decls = [[2]];
  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 ("read_time" in data && data.read_time != void 0) {
        this.read_time = data.read_time;
      }
    }
  }
  get read_time() {
    return pb_16.Message.getWrapperField(this, Timestamp, 2);
  }
  set read_time(value) {
    pb_16.Message.setOneofWrapperField(this, 2, this.#one_of_decls[0], value);
  }
  get has_read_time() {
    return pb_16.Message.getField(this, 2) != null;
  }
  get consistency_selector() {
    const cases = {
      0: "none",
      2: "read_time"
    };
    return cases[pb_16.Message.computeOneofCase(this, [2])];
  }
  static fromObject(data) {
    const message = new _TransactionOptionsReadOnly({});
    if (data.read_time != null) {
      message.read_time = Timestamp.fromObject(data.read_time);
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.read_time != null) {
      data.read_time = this.read_time.toObject();
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_16.BinaryWriter();
    if (this.has_read_time)
      writer.writeMessage(2, this.read_time, () => this.read_time.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 _TransactionOptionsReadOnly();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 2:
          reader.readMessage(message.read_time, () => message.read_time = Timestamp.deserialize(reader));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _TransactionOptionsReadOnly.deserialize(bytes);
  }
};

// generated/google/protobuf/wrappers.ts
import * as pb_17 from "google-protobuf";
var DoubleValue = class _DoubleValue extends pb_17.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_17.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_17.Message.getFieldWithDefault(this, 1, 0);
  }
  set value(value) {
    pb_17.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_17.BinaryWriter();
    if (this.value != 0)
      writer.writeDouble(1, this.value);
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_17.BinaryReader ? bytes : new pb_17.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_17.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_17.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_17.Message.getFieldWithDefault(this, 1, 0);
  }
  set value(value) {
    pb_17.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_17.BinaryWriter();
    if (this.value != 0)
      writer.w