@firestore-emulator/proto/dist/google/firestore/v1beta1/write.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/v1beta1/write.ts
var write_exports = {};
__export(write_exports, {
  DocumentChange: () => DocumentChange,
  DocumentDelete: () => DocumentDelete,
  DocumentRemove: () => DocumentRemove,
  DocumentTransform: () => DocumentTransform,
  DocumentTransformFieldTransform: () => DocumentTransformFieldTransform,
  DocumentTransformFieldTransformServerValue: () => DocumentTransformFieldTransformServerValue,
  ExistenceFilter: () => ExistenceFilter,
  Write: () => Write,
  WriteResult: () => WriteResult
});
module.exports = __toCommonJS(write_exports);

// generated/google/protobuf/timestamp.ts
var pb_1 = __toESM(require("google-protobuf"));
var Timestamp = class _Timestamp 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 ("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_1.Message.getFieldWithDefault(this, 1, 0);
  }
  set seconds(value) {
    pb_1.Message.setField(this, 1, value);
  }
  get nanos() {
    return pb_1.Message.getFieldWithDefault(this, 2, 0);
  }
  set nanos(value) {
    pb_1.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_1.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_1.BinaryReader ? bytes : new pb_1.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/firestore/v1beta1/common.ts
var pb_12 = __toESM(require("google-protobuf"));
var DocumentMask = class _DocumentMask extends pb_12.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_12.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_12.Message.getFieldWithDefault(this, 1, []);
  }
  set field_paths(value) {
    pb_12.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_12.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_12.BinaryReader ? bytes : new pb_12.BinaryReader(bytes), message = new _DocumentMask();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          pb_12.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_12.Message {
  #one_of_decls = [[1, 2]];
  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 ("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_12.Message.getFieldWithDefault(this, 1, false);
  }
  set exists(value) {
    pb_12.Message.setOneofField(this, 1, this.#one_of_decls[0], value);
  }
  get has_exists() {
    return pb_12.Message.getField(this, 1) != null;
  }
  get update_time() {
    return pb_12.Message.getWrapperField(this, Timestamp, 2);
  }
  set update_time(value) {
    pb_12.Message.setOneofWrapperField(this, 2, this.#one_of_decls[0], value);
  }
  get has_update_time() {
    return pb_12.Message.getField(this, 2) != null;
  }
  get condition_type() {
    const cases = {
      0: "none",
      1: "exists",
      2: "update_time"
    };
    return cases[pb_12.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_12.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_12.BinaryReader ? bytes : new pb_12.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);
  }
};

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

// generated/google/type/latlng.ts
var pb_14 = __toESM(require("google-protobuf"));
var LatLng = class _LatLng 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 ("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_14.Message.getFieldWithDefault(this, 1, 0);
  }
  set latitude(value) {
    pb_14.Message.setField(this, 1, value);
  }
  get longitude() {
    return pb_14.Message.getFieldWithDefault(this, 2, 0);
  }
  set longitude(value) {
    pb_14.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_14.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_14.BinaryReader ? bytes : new pb_14.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/v1beta1/document.ts
var pb_15 = __toESM(require("google-protobuf"));
var Document = class _Document 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 ("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_15.Message.getFieldWithDefault(this, 1, "");
  }
  set name(value) {
    pb_15.Message.setField(this, 1, value);
  }
  get fields() {
    return pb_15.Message.getField(this, 2);
  }
  set fields(value) {
    pb_15.Message.setField(this, 2, value);
  }
  get create_time() {
    return pb_15.Message.getWrapperField(this, Timestamp, 3);
  }
  set create_time(value) {
    pb_15.Message.setWrapperField(this, 3, value);
  }
  get has_create_time() {
    return pb_15.Message.getField(this, 3) != null;
  }
  get update_time() {
    return pb_15.Message.getWrapperField(this, Timestamp, 4);
  }
  set update_time(value) {
    pb_15.Message.setWrapperField(this, 4, value);
  }
  get has_update_time() {
    return pb_15.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, Value.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_15.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_15.BinaryReader ? bytes : new pb_15.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_15.Map.deserializeBinary(message.fields, reader, reader.readString, () => {
            let value;
            reader.readMessage(message, () => value = Value.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 Value = class _Value extends pb_15.Message {
  #one_of_decls = [[11, 1, 2, 3, 10, 17, 18, 5, 8, 9, 6]];
  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 ("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_15.Message.getFieldWithDefault(this, 11, 0 /* NULL_VALUE */);
  }
  set null_value(value) {
    pb_15.Message.setOneofField(this, 11, this.#one_of_decls[0], value);
  }
  get has_null_value() {
    return pb_15.Message.getField(this, 11) != null;
  }
  get boolean_value() {
    return pb_15.Message.getFieldWithDefault(this, 1, false);
  }
  set boolean_value(value) {
    pb_15.Message.setOneofField(this, 1, this.#one_of_decls[0], value);
  }
  get has_boolean_value() {
    return pb_15.Message.getField(this, 1) != null;
  }
  get integer_value() {
    return pb_15.Message.getFieldWithDefault(this, 2, 0);
  }
  set integer_value(value) {
    pb_15.Message.setOneofField(this, 2, this.#one_of_decls[0], value);
  }
  get has_integer_value() {
    return pb_15.Message.getField(this, 2) != null;
  }
  get double_value() {
    return pb_15.Message.getFieldWithDefault(this, 3, 0);
  }
  set double_value(value) {
    pb_15.Message.setOneofField(this, 3, this.#one_of_decls[0], value);
  }
  get has_double_value() {
    return pb_15.Message.getField(this, 3) != null;
  }
  get timestamp_value() {
    return pb_15.Message.getWrapperField(this, Timestamp, 10);
  }
  set timestamp_value(value) {
    pb_15.Message.setOneofWrapperField(this, 10, this.#one_of_decls[0], value);
  }
  get has_timestamp_value() {
    return pb_15.Message.getField(this, 10) != null;
  }
  get string_value() {
    return pb_15.Message.getFieldWithDefault(this, 17, "");
  }
  set string_value(value) {
    pb_15.Message.setOneofField(this, 17, this.#one_of_decls[0], value);
  }
  get has_string_value() {
    return pb_15.Message.getField(this, 17) != null;
  }
  get bytes_value() {
    return pb_15.Message.getFieldWithDefault(this, 18, new Uint8Array(0));
  }
  set bytes_value(value) {
    pb_15.Message.setOneofField(this, 18, this.#one_of_decls[0], value);
  }
  get has_bytes_value() {
    return pb_15.Message.getField(this, 18) != null;
  }
  get reference_value() {
    return pb_15.Message.getFieldWithDefault(this, 5, "");
  }
  set reference_value(value) {
    pb_15.Message.setOneofField(this, 5, this.#one_of_decls[0], value);
  }
  get has_reference_value() {
    return pb_15.Message.getField(this, 5) != null;
  }
  get geo_point_value() {
    return pb_15.Message.getWrapperField(this, LatLng, 8);
  }
  set geo_point_value(value) {
    pb_15.Message.setOneofWrapperField(this, 8, this.#one_of_decls[0], value);
  }
  get has_geo_point_value() {
    return pb_15.Message.getField(this, 8) != null;
  }
  get array_value() {
    return pb_15.Message.getWrapperField(this, ArrayValue, 9);
  }
  set array_value(value) {
    pb_15.Message.setOneofWrapperField(this, 9, this.#one_of_decls[0], value);
  }
  get has_array_value() {
    return pb_15.Message.getField(this, 9) != null;
  }
  get map_value() {
    return pb_15.Message.getWrapperField(this, MapValue, 6);
  }
  set map_value(value) {
    pb_15.Message.setOneofWrapperField(this, 6, this.#one_of_decls[0], value);
  }
  get has_map_value() {
    return pb_15.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_15.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_15.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_15.BinaryReader ? bytes : new pb_15.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_15.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_15.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_15.Message.getRepeatedWrapperField(this, Value, 1);
  }
  set values(value) {
    pb_15.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_15.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_15.BinaryReader ? bytes : new pb_15.BinaryReader(bytes), message = new _ArrayValue();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          reader.readMessage(message.values, () => pb_15.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_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 ("fields" in data && data.fields != void 0) {
        this.fields = data.fields;
      }
    }
    if (!this.fields)
      this.fields = /* @__PURE__ */ new Map();
  }
  get fields() {
    return pb_15.Message.getField(this, 1);
  }
  set fields(value) {
    pb_15.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_15.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_15.BinaryReader ? bytes : new pb_15.BinaryReader(bytes), message = new _MapValue();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          reader.readMessage(message, () => pb_15.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/firestore/v1beta1/write.ts
var pb_16 = __toESM(require("google-protobuf"));
var Write = class _Write extends pb_16.Message {
  #one_of_decls = [[1, 2, 6]];
  constructor(data) {
    super();
    pb_16.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [7], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("update" in data && data.update != void 0) {
        this.update = data.update;
      }
      if ("delete" in data && data.delete != void 0) {
        this.delete = data.delete;
      }
      if ("transform" in data && data.transform != void 0) {
        this.transform = data.transform;
      }
      if ("update_mask" in data && data.update_mask != void 0) {
        this.update_mask = data.update_mask;
      }
      if ("update_transforms" in data && data.update_transforms != void 0) {
        this.update_transforms = data.update_transforms;
      }
      if ("current_document" in data && data.current_document != void 0) {
        this.current_document = data.current_document;
      }
    }
  }
  get update() {
    return pb_16.Message.getWrapperField(this, Document, 1);
  }
  set update(value) {
    pb_16.Message.setOneofWrapperField(this, 1, this.#one_of_decls[0], value);
  }
  get has_update() {
    return pb_16.Message.getField(this, 1) != null;
  }
  get delete() {
    return pb_16.Message.getFieldWithDefault(this, 2, "");
  }
  set delete(value) {
    pb_16.Message.setOneofField(this, 2, this.#one_of_decls[0], value);
  }
  get has_delete() {
    return pb_16.Message.getField(this, 2) != null;
  }
  get transform() {
    return pb_16.Message.getWrapperField(this, DocumentTransform, 6);
  }
  set transform(value) {
    pb_16.Message.setOneofWrapperField(this, 6, this.#one_of_decls[0], value);
  }
  get has_transform() {
    return pb_16.Message.getField(this, 6) != null;
  }
  get update_mask() {
    return pb_16.Message.getWrapperField(this, DocumentMask, 3);
  }
  set update_mask(value) {
    pb_16.Message.setWrapperField(this, 3, value);
  }
  get has_update_mask() {
    return pb_16.Message.getField(this, 3) != null;
  }
  get update_transforms() {
    return pb_16.Message.getRepeatedWrapperField(this, DocumentTransformFieldTransform, 7);
  }
  set update_transforms(value) {
    pb_16.Message.setRepeatedWrapperField(this, 7, value);
  }
  get current_document() {
    return pb_16.Message.getWrapperField(this, Precondition, 4);
  }
  set current_document(value) {
    pb_16.Message.setWrapperField(this, 4, value);
  }
  get has_current_document() {
    return pb_16.Message.getField(this, 4) != null;
  }
  get operation() {
    const cases = {
      0: "none",
      1: "update",
      2: "delete",
      6: "transform"
    };
    return cases[pb_16.Message.computeOneofCase(this, [1, 2, 6])];
  }
  static fromObject(data) {
    const message = new _Write({});
    if (data.update != null) {
      message.update = Document.fromObject(data.update);
    }
    if (data.delete != null) {
      message.delete = data.delete;
    }
    if (data.transform != null) {
      message.transform = DocumentTransform.fromObject(data.transform);
    }
    if (data.update_mask != null) {
      message.update_mask = DocumentMask.fromObject(data.update_mask);
    }
    if (data.update_transforms != null) {
      message.update_transforms = data.update_transforms.map((item) => DocumentTransformFieldTransform.fromObject(item));
    }
    if (data.current_document != null) {
      message.current_document = Precondition.fromObject(data.current_document);
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.update != null) {
      data.update = this.update.toObject();
    }
    if (this.delete != null) {
      data.delete = this.delete;
    }
    if (this.transform != null) {
      data.transform = this.transform.toObject();
    }
    if (this.update_mask != null) {
      data.update_mask = this.update_mask.toObject();
    }
    if (this.update_transforms != null) {
      data.update_transforms = this.update_transforms.map((item) => item.toObject());
    }
    if (this.current_document != null) {
      data.current_document = this.current_document.toObject();
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_16.BinaryWriter();
    if (this.has_update)
      writer.writeMessage(1, this.update, () => this.update.serialize(writer));
    if (this.has_delete)
      writer.writeString(2, this.delete);
    if (this.has_transform)
      writer.writeMessage(6, this.transform, () => this.transform.serialize(writer));
    if (this.has_update_mask)
      writer.writeMessage(3, this.update_mask, () => this.update_mask.serialize(writer));
    if (this.update_transforms.length)
      writer.writeRepeatedMessage(7, this.update_transforms, (item) => item.serialize(writer));
    if (this.has_current_document)
      writer.writeMessage(4, this.current_document, () => this.current_document.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 _Write();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          reader.readMessage(message.update, () => message.update = Document.deserialize(reader));
          break;
        case 2:
          message.delete = reader.readString();
          break;
        case 6:
          reader.readMessage(message.transform, () => message.transform = DocumentTransform.deserialize(reader));
          break;
        case 3:
          reader.readMessage(message.update_mask, () => message.update_mask = DocumentMask.deserialize(reader));
          break;
        case 7:
          reader.readMessage(message.update_transforms, () => pb_16.Message.addToRepeatedWrapperField(message, 7, DocumentTransformFieldTransform.deserialize(reader), DocumentTransformFieldTransform));
          break;
        case 4:
          reader.readMessage(message.current_document, () => message.current_document = Precondition.deserialize(reader));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _Write.deserialize(bytes);
  }
};
var DocumentTransform = class _DocumentTransform 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 ("document" in data && data.document != void 0) {
        this.document = data.document;
      }
      if ("field_transforms" in data && data.field_transforms != void 0) {
        this.field_transforms = data.field_transforms;
      }
    }
  }
  get document() {
    return pb_16.Message.getFieldWithDefault(this, 1, "");
  }
  set document(value) {
    pb_16.Message.setField(this, 1, value);
  }
  get field_transforms() {
    return pb_16.Message.getRepeatedWrapperField(this, DocumentTransformFieldTransform, 2);
  }
  set field_transforms(value) {
    pb_16.Message.setRepeatedWrapperField(this, 2, value);
  }
  static fromObject(data) {
    const message = new _DocumentTransform({});
    if (data.document != null) {
      message.document = data.document;
    }
    if (data.field_transforms != null) {
      message.field_transforms = data.field_transforms.map((item) => DocumentTransformFieldTransform.fromObject(item));
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.document != null) {
      data.document = this.document;
    }
    if (this.field_transforms != null) {
      data.field_transforms = this.field_transforms.map((item) => item.toObject());
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_16.BinaryWriter();
    if (this.document.length)
      writer.writeString(1, this.document);
    if (this.field_transforms.length)
      writer.writeRepeatedMessage(2, this.field_transforms, (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 _DocumentTransform();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.document = reader.readString();
          break;
        case 2:
          reader.readMessage(message.field_transforms, () => pb_16.Message.addToRepeatedWrapperField(message, 2, DocumentTransformFieldTransform.deserialize(reader), DocumentTransformFieldTransform));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _DocumentTransform.deserialize(bytes);
  }
};
var DocumentTransformFieldTransform = class _DocumentTransformFieldTransform extends pb_16.Message {
  #one_of_decls = [[2, 3, 4, 5, 6, 7]];
  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_path" in data && data.field_path != void 0) {
        this.field_path = data.field_path;
      }
      if ("set_to_server_value" in data && data.set_to_server_value != void 0) {
        this.set_to_server_value = data.set_to_server_value;
      }
      if ("increment" in data && data.increment != void 0) {
        this.increment = data.increment;
      }
      if ("maximum" in data && data.maximum != void 0) {
        this.maximum = data.maximum;
      }
      if ("minimum" in data && data.minimum != void 0) {
        this.minimum = data.minimum;
      }
      if ("append_missing_elements" in data && data.append_missing_elements != void 0) {
        this.append_missing_elements = data.append_missing_elements;
      }
      if ("remove_all_from_array" in data && data.remove_all_from_array != void 0) {
        this.remove_all_from_array = data.remove_all_from_array;
      }
    }
  }
  get field_path() {
    return pb_16.Message.getFieldWithDefault(this, 1, "");
  }
  set field_path(value) {
    pb_16.Message.setField(this, 1, value);
  }
  get set_to_server_value() {
    return pb_16.Message.getFieldWithDefault(this, 2, 0 /* SERVER_VALUE_UNSPECIFIED */);
  }
  set set_to_server_value(value) {
    pb_16.Message.setOneofField(this, 2, this.#one_of_decls[0], value);
  }
  get has_set_to_server_value() {
    return pb_16.Message.getField(this, 2) != null;
  }
  get increment() {
    return pb_16.Message.getWrapperField(this, Value, 3);
  }
  set increment(value) {
    pb_16.Message.setOneofWrapperField(this, 3, this.#one_of_decls[0], value);
  }
  get has_increment() {
    return pb_16.Message.getField(this, 3) != null;
  }
  get maximum() {
    return pb_16.Message.getWrapperField(this, Value, 4);
  }
  set maximum(value) {
    pb_16.Message.setOneofWrapperField(this, 4, this.#one_of_decls[0], value);
  }
  get has_maximum() {
    return pb_16.Message.getField(this, 4) != null;
  }
  get minimum() {
    return pb_16.Message.getWrapperField(this, Value, 5);
  }
  set minimum(value) {
    pb_16.Message.setOneofWrapperField(this, 5, this.#one_of_decls[0], value);
  }
  get has_minimum() {
    return pb_16.Message.getField(this, 5) != null;
  }
  get append_missing_elements() {
    return pb_16.Message.getWrapperField(this, ArrayValue, 6);
  }
  set append_missing_elements(value) {
    pb_16.Message.setOneofWrapperField(this, 6, this.#one_of_decls[0], value);
  }
  get has_append_missing_elements() {
    return pb_16.Message.getField(this, 6) != null;
  }
  get remove_all_from_array() {
    return pb_16.Message.getWrapperField(this, ArrayValue, 7);
  }
  set remove_all_from_array(value) {
    pb_16.Message.setOneofWrapperField(this, 7, this.#one_of_decls[0], value);
  }
  get has_remove_all_from_array() {
    return pb_16.Message.getField(this, 7) != null;
  }
  get transform_type() {
    const cases = {
      0: "none",
      2: "set_to_server_value",
      3: "increment",
      4: "maximum",
      5: "minimum",
      6: "append_missing_elements",
      7: "remove_all_from_array"
    };
    return cases[pb_16.Message.computeOneofCase(this, [2, 3, 4, 5, 6, 7])];
  }
  static fromObject(data) {
    const message = new _DocumentTransformFieldTransform({});
    if (data.field_path != null) {
      message.field_path = data.field_path;
    }
    if (data.set_to_server_value != null) {
      message.set_to_server_value = data.set_to_server_value;
    }
    if (data.increment != null) {
      message.increment = Value.fromObject(data.increment);
    }
    if (data.maximum != null) {
      message.maximum = Value.fromObject(data.maximum);
    }
    if (data.minimum != null) {
      message.minimum = Value.fromObject(data.minimum);
    }
    if (data.append_missing_elements != null) {
      message.append_missing_elements = ArrayValue.fromObject(data.append_missing_elements);
    }
    if (data.remove_all_from_array != null) {
      message.remove_all_from_array = ArrayValue.fromObject(data.remove_all_from_array);
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.field_path != null) {
      data.field_path = this.field_path;
    }
    if (this.set_to_server_value != null) {
      data.set_to_server_value = this.set_to_server_value;
    }
    if (this.increment != null) {
      data.increment = this.increment.toObject();
    }
    if (this.maximum != null) {
      data.maximum = this.maximum.toObject();
    }
    if (this.minimum != null) {
      data.minimum = this.minimum.toObject();
    }
    if (this.append_missing_elements != null) {
      data.append_missing_elements = this.append_missing_elements.toObject();
    }
    if (this.remove_all_from_array != null) {
      data.remove_all_from_array = this.remove_all_from_array.toObject();
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_16.BinaryWriter();
    if (this.field_path.length)
      writer.writeString(1, this.field_path);
    if (this.has_set_to_server_value)
      writer.writeEnum(2, this.set_to_server_value);
    if (this.has_increment)
      writer.writeMessage(3, this.increment, () => this.increment.serialize(writer));
    if (this.has_maximum)
      writer.writeMessage(4, this.maximum, () => this.maximum.serialize(writer));
    if (this.has_minimum)
      writer.writeMessage(5, this.minimum, () => this.minimum.serialize(writer));
    if (this.has_append_missing_elements)
      writer.writeMessage(6, this.append_missing_elements, () => this.append_missing_elements.serialize(writer));
    if (this.has_remove_all_from_array)
      writer.writeMessage(7, this.remove_all_from_array, () => this.remove_all_from_array.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 _DocumentTransformFieldTransform();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.field_path = reader.readString();
          break;
        case 2:
          message.set_to_server_value = reader.readEnum();
          break;
        case 3:
          reader.readMessage(message.increment, () => message.increment = Value.deserialize(reader));
          break;
        case 4:
          reader.readMessage(message.maximum, () => message.maximum = Value.deserialize(reader));
          break;
        case 5:
          reader.readMessage(message.minimum, () => message.minimum = Value.deserialize(reader));
          break;
        case 6:
          reader.readMessage(message.append_missing_elements, () => message.append_missing_elements = ArrayValue.deserialize(reader));
          break;
        case 7:
          reader.readMessage(message.remove_all_from_array, () => message.remove_all_from_array = ArrayValue.deserialize(reader));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _DocumentTransformFieldTransform.deserialize(bytes);
  }
};
var DocumentTransformFieldTransformServerValue = /* @__PURE__ */ ((DocumentTransformFieldTransformServerValue2) => {
  DocumentTransformFieldTransformServerValue2[DocumentTransformFieldTransformServerValue2["SERVER_VALUE_UNSPECIFIED"] = 0] = "SERVER_VALUE_UNSPECIFIED";
  DocumentTransformFieldTransformServerValue2[DocumentTransformFieldTransformServerValue2["REQUEST_TIME"] = 1] = "REQUEST_TIME";
  return DocumentTransformFieldTransformServerValue2;
})(DocumentTransformFieldTransformServerValue || {});
var WriteResult = class _WriteResult 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 ("update_time" in data && data.update_time != void 0) {
        this.update_time = data.update_time;
      }
      if ("transform_results" in data && data.transform_results != void 0) {
        this.transform_results = data.transform_results;
      }
    }
  }
  get update_time() {
    return pb_16.Message.getWrapperField(this, Timestamp, 1);
  }
  set update_time(value) {
    pb_16.Message.setWrapperField(this, 1, value);
  }
  get has_update_time() {
    return pb_16.Message.getField(this, 1) != null;
  }
  get transform_results() {
    return pb_16.Message.getRepeatedWrapperField(this, Value, 2);
  }
  set transform_results(value) {
    pb_16.Message.setRepeatedWrapperField(this, 2, value);
  }
  static fromObject(data) {
    const message = new _WriteResult({});
    if (data.update_time != null) {
      message.update_time = Timestamp.fromObject(data.update_time);
    }
    if (data.transform_results != null) {
      message.transform_results = data.transform_results.map((item) => Value.fromObject(item));
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.update_time != null) {
      data.update_time = this.update_time.toObject();
    }
    if (this.transform_results != null) {
      data.transform_results = this.transform_results.map((item) => item.toObject());
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_16.BinaryWriter();
    if (this.has_update_time)
      writer.writeMessage(1, this.update_time, () => this.update_time.serialize(writer));
    if (this.transform_results.length)
      writer.writeRepeatedMessage(2, this.transform_results, (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 _WriteResult();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          reader.readMessage(message.update_time, () => message.update_time = Timestamp.deserialize(reader));
          break;
        case 2:
          reader.readMessage(message.transform_results, () => pb_16.Message.addToRepeatedWrapperField(message, 2, Value.deserialize(reader), Value));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _WriteResult.deserialize(bytes);
  }
};
var DocumentChange = class _DocumentChange extends pb_16.Message {
  #one_of_decls = [];
  constructor(data) {
    su