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

Generated Firestore Protobufs For Firestore Emulator

// generated/google/firestore/admin/v1/index.ts
import * as pb_1 from "google-protobuf";
var Index = class _Index extends pb_1.Message {
  #one_of_decls = [];
  constructor(data) {
    super();
    pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [3], this.#one_of_decls);
    if (!Array.isArray(data) && typeof data == "object") {
      if ("name" in data && data.name != void 0) {
        this.name = data.name;
      }
      if ("query_scope" in data && data.query_scope != void 0) {
        this.query_scope = data.query_scope;
      }
      if ("api_scope" in data && data.api_scope != void 0) {
        this.api_scope = data.api_scope;
      }
      if ("fields" in data && data.fields != void 0) {
        this.fields = data.fields;
      }
      if ("state" in data && data.state != void 0) {
        this.state = data.state;
      }
    }
  }
  get name() {
    return pb_1.Message.getFieldWithDefault(this, 1, "");
  }
  set name(value) {
    pb_1.Message.setField(this, 1, value);
  }
  get query_scope() {
    return pb_1.Message.getFieldWithDefault(this, 2, 0 /* QUERY_SCOPE_UNSPECIFIED */);
  }
  set query_scope(value) {
    pb_1.Message.setField(this, 2, value);
  }
  get api_scope() {
    return pb_1.Message.getFieldWithDefault(this, 5, 0 /* ANY_API */);
  }
  set api_scope(value) {
    pb_1.Message.setField(this, 5, value);
  }
  get fields() {
    return pb_1.Message.getRepeatedWrapperField(this, IndexIndexField, 3);
  }
  set fields(value) {
    pb_1.Message.setRepeatedWrapperField(this, 3, value);
  }
  get state() {
    return pb_1.Message.getFieldWithDefault(this, 4, 0 /* STATE_UNSPECIFIED */);
  }
  set state(value) {
    pb_1.Message.setField(this, 4, value);
  }
  static fromObject(data) {
    const message = new _Index({});
    if (data.name != null) {
      message.name = data.name;
    }
    if (data.query_scope != null) {
      message.query_scope = data.query_scope;
    }
    if (data.api_scope != null) {
      message.api_scope = data.api_scope;
    }
    if (data.fields != null) {
      message.fields = data.fields.map((item) => IndexIndexField.fromObject(item));
    }
    if (data.state != null) {
      message.state = data.state;
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.name != null) {
      data.name = this.name;
    }
    if (this.query_scope != null) {
      data.query_scope = this.query_scope;
    }
    if (this.api_scope != null) {
      data.api_scope = this.api_scope;
    }
    if (this.fields != null) {
      data.fields = this.fields.map((item) => item.toObject());
    }
    if (this.state != null) {
      data.state = this.state;
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_1.BinaryWriter();
    if (this.name.length)
      writer.writeString(1, this.name);
    if (this.query_scope != 0 /* QUERY_SCOPE_UNSPECIFIED */)
      writer.writeEnum(2, this.query_scope);
    if (this.api_scope != 0 /* ANY_API */)
      writer.writeEnum(5, this.api_scope);
    if (this.fields.length)
      writer.writeRepeatedMessage(3, this.fields, (item) => item.serialize(writer));
    if (this.state != 0 /* STATE_UNSPECIFIED */)
      writer.writeEnum(4, this.state);
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new _Index();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.name = reader.readString();
          break;
        case 2:
          message.query_scope = reader.readEnum();
          break;
        case 5:
          message.api_scope = reader.readEnum();
          break;
        case 3:
          reader.readMessage(message.fields, () => pb_1.Message.addToRepeatedWrapperField(message, 3, IndexIndexField.deserialize(reader), IndexIndexField));
          break;
        case 4:
          message.state = reader.readEnum();
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _Index.deserialize(bytes);
  }
};
var IndexIndexField = class _IndexIndexField extends pb_1.Message {
  #one_of_decls = [[2, 3, 4]];
  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 ("field_path" in data && data.field_path != void 0) {
        this.field_path = data.field_path;
      }
      if ("order" in data && data.order != void 0) {
        this.order = data.order;
      }
      if ("array_config" in data && data.array_config != void 0) {
        this.array_config = data.array_config;
      }
      if ("vector_config" in data && data.vector_config != void 0) {
        this.vector_config = data.vector_config;
      }
    }
  }
  get field_path() {
    return pb_1.Message.getFieldWithDefault(this, 1, "");
  }
  set field_path(value) {
    pb_1.Message.setField(this, 1, value);
  }
  get order() {
    return pb_1.Message.getFieldWithDefault(this, 2, 0 /* ORDER_UNSPECIFIED */);
  }
  set order(value) {
    pb_1.Message.setOneofField(this, 2, this.#one_of_decls[0], value);
  }
  get has_order() {
    return pb_1.Message.getField(this, 2) != null;
  }
  get array_config() {
    return pb_1.Message.getFieldWithDefault(this, 3, 0 /* ARRAY_CONFIG_UNSPECIFIED */);
  }
  set array_config(value) {
    pb_1.Message.setOneofField(this, 3, this.#one_of_decls[0], value);
  }
  get has_array_config() {
    return pb_1.Message.getField(this, 3) != null;
  }
  get vector_config() {
    return pb_1.Message.getWrapperField(this, IndexIndexFieldVectorConfig, 4);
  }
  set vector_config(value) {
    pb_1.Message.setOneofWrapperField(this, 4, this.#one_of_decls[0], value);
  }
  get has_vector_config() {
    return pb_1.Message.getField(this, 4) != null;
  }
  get value_mode() {
    const cases = {
      0: "none",
      2: "order",
      3: "array_config",
      4: "vector_config"
    };
    return cases[pb_1.Message.computeOneofCase(this, [2, 3, 4])];
  }
  static fromObject(data) {
    const message = new _IndexIndexField({});
    if (data.field_path != null) {
      message.field_path = data.field_path;
    }
    if (data.order != null) {
      message.order = data.order;
    }
    if (data.array_config != null) {
      message.array_config = data.array_config;
    }
    if (data.vector_config != null) {
      message.vector_config = IndexIndexFieldVectorConfig.fromObject(data.vector_config);
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.field_path != null) {
      data.field_path = this.field_path;
    }
    if (this.order != null) {
      data.order = this.order;
    }
    if (this.array_config != null) {
      data.array_config = this.array_config;
    }
    if (this.vector_config != null) {
      data.vector_config = this.vector_config.toObject();
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_1.BinaryWriter();
    if (this.field_path.length)
      writer.writeString(1, this.field_path);
    if (this.has_order)
      writer.writeEnum(2, this.order);
    if (this.has_array_config)
      writer.writeEnum(3, this.array_config);
    if (this.has_vector_config)
      writer.writeMessage(4, this.vector_config, () => this.vector_config.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 _IndexIndexField();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.field_path = reader.readString();
          break;
        case 2:
          message.order = reader.readEnum();
          break;
        case 3:
          message.array_config = reader.readEnum();
          break;
        case 4:
          reader.readMessage(message.vector_config, () => message.vector_config = IndexIndexFieldVectorConfig.deserialize(reader));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _IndexIndexField.deserialize(bytes);
  }
};
var IndexIndexFieldVectorConfig = class _IndexIndexFieldVectorConfig extends pb_1.Message {
  #one_of_decls = [[2]];
  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 ("dimension" in data && data.dimension != void 0) {
        this.dimension = data.dimension;
      }
      if ("flat" in data && data.flat != void 0) {
        this.flat = data.flat;
      }
    }
  }
  get dimension() {
    return pb_1.Message.getFieldWithDefault(this, 1, 0);
  }
  set dimension(value) {
    pb_1.Message.setField(this, 1, value);
  }
  get flat() {
    return pb_1.Message.getWrapperField(this, IndexIndexFieldVectorConfigFlatIndex, 2);
  }
  set flat(value) {
    pb_1.Message.setOneofWrapperField(this, 2, this.#one_of_decls[0], value);
  }
  get has_flat() {
    return pb_1.Message.getField(this, 2) != null;
  }
  get type() {
    const cases = {
      0: "none",
      2: "flat"
    };
    return cases[pb_1.Message.computeOneofCase(this, [2])];
  }
  static fromObject(data) {
    const message = new _IndexIndexFieldVectorConfig({});
    if (data.dimension != null) {
      message.dimension = data.dimension;
    }
    if (data.flat != null) {
      message.flat = IndexIndexFieldVectorConfigFlatIndex.fromObject(data.flat);
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.dimension != null) {
      data.dimension = this.dimension;
    }
    if (this.flat != null) {
      data.flat = this.flat.toObject();
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_1.BinaryWriter();
    if (this.dimension != 0)
      writer.writeInt32(1, this.dimension);
    if (this.has_flat)
      writer.writeMessage(2, this.flat, () => this.flat.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 _IndexIndexFieldVectorConfig();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.dimension = reader.readInt32();
          break;
        case 2:
          reader.readMessage(message.flat, () => message.flat = IndexIndexFieldVectorConfigFlatIndex.deserialize(reader));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _IndexIndexFieldVectorConfig.deserialize(bytes);
  }
};
var IndexIndexFieldVectorConfigFlatIndex = class _IndexIndexFieldVectorConfigFlatIndex 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") {
    }
  }
  static fromObject(data) {
    const message = new _IndexIndexFieldVectorConfigFlatIndex({});
    return message;
  }
  toObject() {
    const data = {};
    return data;
  }
  serialize(w) {
    const writer = w || new pb_1.BinaryWriter();
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new _IndexIndexFieldVectorConfigFlatIndex();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _IndexIndexFieldVectorConfigFlatIndex.deserialize(bytes);
  }
};

// generated/google/firestore/admin/v1/field.ts
import * as pb_12 from "google-protobuf";
var Field = class _Field 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 ("name" in data && data.name != void 0) {
        this.name = data.name;
      }
      if ("index_config" in data && data.index_config != void 0) {
        this.index_config = data.index_config;
      }
      if ("ttl_config" in data && data.ttl_config != void 0) {
        this.ttl_config = data.ttl_config;
      }
    }
  }
  get name() {
    return pb_12.Message.getFieldWithDefault(this, 1, "");
  }
  set name(value) {
    pb_12.Message.setField(this, 1, value);
  }
  get index_config() {
    return pb_12.Message.getWrapperField(this, FieldIndexConfig, 2);
  }
  set index_config(value) {
    pb_12.Message.setWrapperField(this, 2, value);
  }
  get has_index_config() {
    return pb_12.Message.getField(this, 2) != null;
  }
  get ttl_config() {
    return pb_12.Message.getWrapperField(this, FieldTtlConfig, 3);
  }
  set ttl_config(value) {
    pb_12.Message.setWrapperField(this, 3, value);
  }
  get has_ttl_config() {
    return pb_12.Message.getField(this, 3) != null;
  }
  static fromObject(data) {
    const message = new _Field({});
    if (data.name != null) {
      message.name = data.name;
    }
    if (data.index_config != null) {
      message.index_config = FieldIndexConfig.fromObject(data.index_config);
    }
    if (data.ttl_config != null) {
      message.ttl_config = FieldTtlConfig.fromObject(data.ttl_config);
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.name != null) {
      data.name = this.name;
    }
    if (this.index_config != null) {
      data.index_config = this.index_config.toObject();
    }
    if (this.ttl_config != null) {
      data.ttl_config = this.ttl_config.toObject();
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_12.BinaryWriter();
    if (this.name.length)
      writer.writeString(1, this.name);
    if (this.has_index_config)
      writer.writeMessage(2, this.index_config, () => this.index_config.serialize(writer));
    if (this.has_ttl_config)
      writer.writeMessage(3, this.ttl_config, () => this.ttl_config.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 _Field();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.name = reader.readString();
          break;
        case 2:
          reader.readMessage(message.index_config, () => message.index_config = FieldIndexConfig.deserialize(reader));
          break;
        case 3:
          reader.readMessage(message.ttl_config, () => message.ttl_config = FieldTtlConfig.deserialize(reader));
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _Field.deserialize(bytes);
  }
};
var FieldIndexConfig = class _FieldIndexConfig 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 ("indexes" in data && data.indexes != void 0) {
        this.indexes = data.indexes;
      }
      if ("uses_ancestor_config" in data && data.uses_ancestor_config != void 0) {
        this.uses_ancestor_config = data.uses_ancestor_config;
      }
      if ("ancestor_field" in data && data.ancestor_field != void 0) {
        this.ancestor_field = data.ancestor_field;
      }
      if ("reverting" in data && data.reverting != void 0) {
        this.reverting = data.reverting;
      }
    }
  }
  get indexes() {
    return pb_12.Message.getRepeatedWrapperField(this, Index, 1);
  }
  set indexes(value) {
    pb_12.Message.setRepeatedWrapperField(this, 1, value);
  }
  get uses_ancestor_config() {
    return pb_12.Message.getFieldWithDefault(this, 2, false);
  }
  set uses_ancestor_config(value) {
    pb_12.Message.setField(this, 2, value);
  }
  get ancestor_field() {
    return pb_12.Message.getFieldWithDefault(this, 3, "");
  }
  set ancestor_field(value) {
    pb_12.Message.setField(this, 3, value);
  }
  get reverting() {
    return pb_12.Message.getFieldWithDefault(this, 4, false);
  }
  set reverting(value) {
    pb_12.Message.setField(this, 4, value);
  }
  static fromObject(data) {
    const message = new _FieldIndexConfig({});
    if (data.indexes != null) {
      message.indexes = data.indexes.map((item) => Index.fromObject(item));
    }
    if (data.uses_ancestor_config != null) {
      message.uses_ancestor_config = data.uses_ancestor_config;
    }
    if (data.ancestor_field != null) {
      message.ancestor_field = data.ancestor_field;
    }
    if (data.reverting != null) {
      message.reverting = data.reverting;
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.indexes != null) {
      data.indexes = this.indexes.map((item) => item.toObject());
    }
    if (this.uses_ancestor_config != null) {
      data.uses_ancestor_config = this.uses_ancestor_config;
    }
    if (this.ancestor_field != null) {
      data.ancestor_field = this.ancestor_field;
    }
    if (this.reverting != null) {
      data.reverting = this.reverting;
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_12.BinaryWriter();
    if (this.indexes.length)
      writer.writeRepeatedMessage(1, this.indexes, (item) => item.serialize(writer));
    if (this.uses_ancestor_config != false)
      writer.writeBool(2, this.uses_ancestor_config);
    if (this.ancestor_field.length)
      writer.writeString(3, this.ancestor_field);
    if (this.reverting != false)
      writer.writeBool(4, this.reverting);
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_12.BinaryReader ? bytes : new pb_12.BinaryReader(bytes), message = new _FieldIndexConfig();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          reader.readMessage(message.indexes, () => pb_12.Message.addToRepeatedWrapperField(message, 1, Index.deserialize(reader), Index));
          break;
        case 2:
          message.uses_ancestor_config = reader.readBool();
          break;
        case 3:
          message.ancestor_field = reader.readString();
          break;
        case 4:
          message.reverting = reader.readBool();
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _FieldIndexConfig.deserialize(bytes);
  }
};
var FieldTtlConfig = class _FieldTtlConfig 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 ("state" in data && data.state != void 0) {
        this.state = data.state;
      }
    }
  }
  get state() {
    return pb_12.Message.getFieldWithDefault(this, 1, 0 /* STATE_UNSPECIFIED */);
  }
  set state(value) {
    pb_12.Message.setField(this, 1, value);
  }
  static fromObject(data) {
    const message = new _FieldTtlConfig({});
    if (data.state != null) {
      message.state = data.state;
    }
    return message;
  }
  toObject() {
    const data = {};
    if (this.state != null) {
      data.state = this.state;
    }
    return data;
  }
  serialize(w) {
    const writer = w || new pb_12.BinaryWriter();
    if (this.state != 0 /* STATE_UNSPECIFIED */)
      writer.writeEnum(1, this.state);
    if (!w)
      return writer.getResultBuffer();
  }
  static deserialize(bytes) {
    const reader = bytes instanceof pb_12.BinaryReader ? bytes : new pb_12.BinaryReader(bytes), message = new _FieldTtlConfig();
    while (reader.nextField()) {
      if (reader.isEndGroup())
        break;
      switch (reader.getFieldNumber()) {
        case 1:
          message.state = reader.readEnum();
          break;
        default:
          reader.skipField();
      }
    }
    return message;
  }
  serializeBinary() {
    return this.serialize();
  }
  static deserializeBinary(bytes) {
    return _FieldTtlConfig.deserialize(bytes);
  }
};
var FieldTtlConfigState = /* @__PURE__ */ ((FieldTtlConfigState2) => {
  FieldTtlConfigState2[FieldTtlConfigState2["STATE_UNSPECIFIED"] = 0] = "STATE_UNSPECIFIED";
  FieldTtlConfigState2[FieldTtlConfigState2["CREATING"] = 1] = "CREATING";
  FieldTtlConfigState2[FieldTtlConfigState2["ACTIVE"] = 2] = "ACTIVE";
  FieldTtlConfigState2[FieldTtlConfigState2["NEEDS_REPAIR"] = 3] = "NEEDS_REPAIR";
  return FieldTtlConfigState2;
})(FieldTtlConfigState || {});
export {
  Field,
  FieldIndexConfig,
  FieldTtlConfig,
  FieldTtlConfigState
};
//# sourceMappingURL=field.mjs.map