@firestore-emulator/proto/dist/google/firestore/v1beta1/document.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/document.ts
var document_exports = {};
__export(document_exports, {
  ArrayValue: () => ArrayValue,
  Document: () => Document,
  MapValue: () => MapValue,
  Value: () => Value
});
module.exports = __toCommonJS(document_exports);

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

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

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

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