@ragnaraven/zitadel-node-dual/dist/api/generated/zitadel/instance.js

Library for API access to ZITADEL with modern ES import syntax. Works everywhere - NestJS, Node.js, any TypeScript environment. No more require()!

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var instance_exports = {};
__export(instance_exports, {
  Domain: () => Domain,
  DomainFieldName: () => DomainFieldName,
  DomainGeneratedQuery: () => DomainGeneratedQuery,
  DomainPrimaryQuery: () => DomainPrimaryQuery,
  DomainQuery: () => DomainQuery,
  DomainSearchQuery: () => DomainSearchQuery,
  DomainsQuery: () => DomainsQuery,
  FieldName: () => FieldName,
  IdsQuery: () => IdsQuery,
  Instance: () => Instance,
  InstanceDetail: () => InstanceDetail,
  Query: () => Query,
  State: () => State,
  TrustedDomain: () => TrustedDomain,
  TrustedDomainSearchQuery: () => TrustedDomainSearchQuery,
  domainFieldNameFromJSON: () => domainFieldNameFromJSON,
  domainFieldNameToJSON: () => domainFieldNameToJSON,
  fieldNameFromJSON: () => fieldNameFromJSON,
  fieldNameToJSON: () => fieldNameToJSON,
  protobufPackage: () => protobufPackage,
  stateFromJSON: () => stateFromJSON,
  stateToJSON: () => stateToJSON
});
module.exports = __toCommonJS(instance_exports);
var import_wire = require("@bufbuild/protobuf/wire");
var import_object = require("./object.js");
const protobufPackage = "zitadel.instance.v1";
var State = /* @__PURE__ */ ((State2) => {
  State2[State2["STATE_UNSPECIFIED"] = 0] = "STATE_UNSPECIFIED";
  State2[State2["STATE_CREATING"] = 1] = "STATE_CREATING";
  State2[State2["STATE_RUNNING"] = 2] = "STATE_RUNNING";
  State2[State2["STATE_STOPPING"] = 3] = "STATE_STOPPING";
  State2[State2["STATE_STOPPED"] = 4] = "STATE_STOPPED";
  State2[State2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
  return State2;
})(State || {});
function stateFromJSON(object) {
  switch (object) {
    case 0:
    case "STATE_UNSPECIFIED":
      return 0 /* STATE_UNSPECIFIED */;
    case 1:
    case "STATE_CREATING":
      return 1 /* STATE_CREATING */;
    case 2:
    case "STATE_RUNNING":
      return 2 /* STATE_RUNNING */;
    case 3:
    case "STATE_STOPPING":
      return 3 /* STATE_STOPPING */;
    case 4:
    case "STATE_STOPPED":
      return 4 /* STATE_STOPPED */;
    case -1:
    case "UNRECOGNIZED":
    default:
      return -1 /* UNRECOGNIZED */;
  }
}
function stateToJSON(object) {
  switch (object) {
    case 0 /* STATE_UNSPECIFIED */:
      return "STATE_UNSPECIFIED";
    case 1 /* STATE_CREATING */:
      return "STATE_CREATING";
    case 2 /* STATE_RUNNING */:
      return "STATE_RUNNING";
    case 3 /* STATE_STOPPING */:
      return "STATE_STOPPING";
    case 4 /* STATE_STOPPED */:
      return "STATE_STOPPED";
    case -1 /* UNRECOGNIZED */:
    default:
      return "UNRECOGNIZED";
  }
}
var FieldName = /* @__PURE__ */ ((FieldName2) => {
  FieldName2[FieldName2["FIELD_NAME_UNSPECIFIED"] = 0] = "FIELD_NAME_UNSPECIFIED";
  FieldName2[FieldName2["FIELD_NAME_ID"] = 1] = "FIELD_NAME_ID";
  FieldName2[FieldName2["FIELD_NAME_NAME"] = 2] = "FIELD_NAME_NAME";
  FieldName2[FieldName2["FIELD_NAME_CREATION_DATE"] = 3] = "FIELD_NAME_CREATION_DATE";
  FieldName2[FieldName2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
  return FieldName2;
})(FieldName || {});
function fieldNameFromJSON(object) {
  switch (object) {
    case 0:
    case "FIELD_NAME_UNSPECIFIED":
      return 0 /* FIELD_NAME_UNSPECIFIED */;
    case 1:
    case "FIELD_NAME_ID":
      return 1 /* FIELD_NAME_ID */;
    case 2:
    case "FIELD_NAME_NAME":
      return 2 /* FIELD_NAME_NAME */;
    case 3:
    case "FIELD_NAME_CREATION_DATE":
      return 3 /* FIELD_NAME_CREATION_DATE */;
    case -1:
    case "UNRECOGNIZED":
    default:
      return -1 /* UNRECOGNIZED */;
  }
}
function fieldNameToJSON(object) {
  switch (object) {
    case 0 /* FIELD_NAME_UNSPECIFIED */:
      return "FIELD_NAME_UNSPECIFIED";
    case 1 /* FIELD_NAME_ID */:
      return "FIELD_NAME_ID";
    case 2 /* FIELD_NAME_NAME */:
      return "FIELD_NAME_NAME";
    case 3 /* FIELD_NAME_CREATION_DATE */:
      return "FIELD_NAME_CREATION_DATE";
    case -1 /* UNRECOGNIZED */:
    default:
      return "UNRECOGNIZED";
  }
}
var DomainFieldName = /* @__PURE__ */ ((DomainFieldName2) => {
  DomainFieldName2[DomainFieldName2["DOMAIN_FIELD_NAME_UNSPECIFIED"] = 0] = "DOMAIN_FIELD_NAME_UNSPECIFIED";
  DomainFieldName2[DomainFieldName2["DOMAIN_FIELD_NAME_DOMAIN"] = 1] = "DOMAIN_FIELD_NAME_DOMAIN";
  DomainFieldName2[DomainFieldName2["DOMAIN_FIELD_NAME_PRIMARY"] = 2] = "DOMAIN_FIELD_NAME_PRIMARY";
  DomainFieldName2[DomainFieldName2["DOMAIN_FIELD_NAME_GENERATED"] = 3] = "DOMAIN_FIELD_NAME_GENERATED";
  DomainFieldName2[DomainFieldName2["DOMAIN_FIELD_NAME_CREATION_DATE"] = 4] = "DOMAIN_FIELD_NAME_CREATION_DATE";
  DomainFieldName2[DomainFieldName2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
  return DomainFieldName2;
})(DomainFieldName || {});
function domainFieldNameFromJSON(object) {
  switch (object) {
    case 0:
    case "DOMAIN_FIELD_NAME_UNSPECIFIED":
      return 0 /* DOMAIN_FIELD_NAME_UNSPECIFIED */;
    case 1:
    case "DOMAIN_FIELD_NAME_DOMAIN":
      return 1 /* DOMAIN_FIELD_NAME_DOMAIN */;
    case 2:
    case "DOMAIN_FIELD_NAME_PRIMARY":
      return 2 /* DOMAIN_FIELD_NAME_PRIMARY */;
    case 3:
    case "DOMAIN_FIELD_NAME_GENERATED":
      return 3 /* DOMAIN_FIELD_NAME_GENERATED */;
    case 4:
    case "DOMAIN_FIELD_NAME_CREATION_DATE":
      return 4 /* DOMAIN_FIELD_NAME_CREATION_DATE */;
    case -1:
    case "UNRECOGNIZED":
    default:
      return -1 /* UNRECOGNIZED */;
  }
}
function domainFieldNameToJSON(object) {
  switch (object) {
    case 0 /* DOMAIN_FIELD_NAME_UNSPECIFIED */:
      return "DOMAIN_FIELD_NAME_UNSPECIFIED";
    case 1 /* DOMAIN_FIELD_NAME_DOMAIN */:
      return "DOMAIN_FIELD_NAME_DOMAIN";
    case 2 /* DOMAIN_FIELD_NAME_PRIMARY */:
      return "DOMAIN_FIELD_NAME_PRIMARY";
    case 3 /* DOMAIN_FIELD_NAME_GENERATED */:
      return "DOMAIN_FIELD_NAME_GENERATED";
    case 4 /* DOMAIN_FIELD_NAME_CREATION_DATE */:
      return "DOMAIN_FIELD_NAME_CREATION_DATE";
    case -1 /* UNRECOGNIZED */:
    default:
      return "UNRECOGNIZED";
  }
}
function createBaseInstance() {
  return { id: "", details: void 0, state: 0, name: "", version: "", domains: [] };
}
const Instance = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    if (message.details !== void 0) {
      import_object.ObjectDetails.encode(message.details, writer.uint32(18).fork()).join();
    }
    if (message.state !== 0) {
      writer.uint32(24).int32(message.state);
    }
    if (message.name !== "") {
      writer.uint32(34).string(message.name);
    }
    if (message.version !== "") {
      writer.uint32(42).string(message.version);
    }
    for (const v of message.domains) {
      Domain.encode(v, writer.uint32(50).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseInstance();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.id = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.details = import_object.ObjectDetails.decode(reader, reader.uint32());
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }
          message.state = reader.int32();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }
          message.name = reader.string();
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }
          message.version = reader.string();
          continue;
        }
        case 6: {
          if (tag !== 50) {
            break;
          }
          message.domains.push(Domain.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      id: isSet(object.id) ? globalThis.String(object.id) : "",
      details: isSet(object.details) ? import_object.ObjectDetails.fromJSON(object.details) : void 0,
      state: isSet(object.state) ? stateFromJSON(object.state) : 0,
      name: isSet(object.name) ? globalThis.String(object.name) : "",
      version: isSet(object.version) ? globalThis.String(object.version) : "",
      domains: globalThis.Array.isArray(object?.domains) ? object.domains.map((e) => Domain.fromJSON(e)) : []
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.id !== "") {
      obj.id = message.id;
    }
    if (message.details !== void 0) {
      obj.details = import_object.ObjectDetails.toJSON(message.details);
    }
    if (message.state !== 0) {
      obj.state = stateToJSON(message.state);
    }
    if (message.name !== "") {
      obj.name = message.name;
    }
    if (message.version !== "") {
      obj.version = message.version;
    }
    if (message.domains?.length) {
      obj.domains = message.domains.map((e) => Domain.toJSON(e));
    }
    return obj;
  },
  create(base) {
    return Instance.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseInstance();
    message.id = object.id ?? "";
    message.details = object.details !== void 0 && object.details !== null ? import_object.ObjectDetails.fromPartial(object.details) : void 0;
    message.state = object.state ?? 0;
    message.name = object.name ?? "";
    message.version = object.version ?? "";
    message.domains = object.domains?.map((e) => Domain.fromPartial(e)) || [];
    return message;
  }
};
function createBaseInstanceDetail() {
  return { id: "", details: void 0, state: 0, name: "", version: "", domains: [] };
}
const InstanceDetail = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    if (message.details !== void 0) {
      import_object.ObjectDetails.encode(message.details, writer.uint32(18).fork()).join();
    }
    if (message.state !== 0) {
      writer.uint32(24).int32(message.state);
    }
    if (message.name !== "") {
      writer.uint32(34).string(message.name);
    }
    if (message.version !== "") {
      writer.uint32(42).string(message.version);
    }
    for (const v of message.domains) {
      Domain.encode(v, writer.uint32(50).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseInstanceDetail();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.id = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.details = import_object.ObjectDetails.decode(reader, reader.uint32());
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }
          message.state = reader.int32();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }
          message.name = reader.string();
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }
          message.version = reader.string();
          continue;
        }
        case 6: {
          if (tag !== 50) {
            break;
          }
          message.domains.push(Domain.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      id: isSet(object.id) ? globalThis.String(object.id) : "",
      details: isSet(object.details) ? import_object.ObjectDetails.fromJSON(object.details) : void 0,
      state: isSet(object.state) ? stateFromJSON(object.state) : 0,
      name: isSet(object.name) ? globalThis.String(object.name) : "",
      version: isSet(object.version) ? globalThis.String(object.version) : "",
      domains: globalThis.Array.isArray(object?.domains) ? object.domains.map((e) => Domain.fromJSON(e)) : []
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.id !== "") {
      obj.id = message.id;
    }
    if (message.details !== void 0) {
      obj.details = import_object.ObjectDetails.toJSON(message.details);
    }
    if (message.state !== 0) {
      obj.state = stateToJSON(message.state);
    }
    if (message.name !== "") {
      obj.name = message.name;
    }
    if (message.version !== "") {
      obj.version = message.version;
    }
    if (message.domains?.length) {
      obj.domains = message.domains.map((e) => Domain.toJSON(e));
    }
    return obj;
  },
  create(base) {
    return InstanceDetail.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseInstanceDetail();
    message.id = object.id ?? "";
    message.details = object.details !== void 0 && object.details !== null ? import_object.ObjectDetails.fromPartial(object.details) : void 0;
    message.state = object.state ?? 0;
    message.name = object.name ?? "";
    message.version = object.version ?? "";
    message.domains = object.domains?.map((e) => Domain.fromPartial(e)) || [];
    return message;
  }
};
function createBaseQuery() {
  return { idQuery: void 0, domainQuery: void 0 };
}
const Query = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.idQuery !== void 0) {
      IdsQuery.encode(message.idQuery, writer.uint32(10).fork()).join();
    }
    if (message.domainQuery !== void 0) {
      DomainsQuery.encode(message.domainQuery, writer.uint32(18).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseQuery();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.idQuery = IdsQuery.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.domainQuery = DomainsQuery.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      idQuery: isSet(object.idQuery) ? IdsQuery.fromJSON(object.idQuery) : void 0,
      domainQuery: isSet(object.domainQuery) ? DomainsQuery.fromJSON(object.domainQuery) : void 0
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.idQuery !== void 0) {
      obj.idQuery = IdsQuery.toJSON(message.idQuery);
    }
    if (message.domainQuery !== void 0) {
      obj.domainQuery = DomainsQuery.toJSON(message.domainQuery);
    }
    return obj;
  },
  create(base) {
    return Query.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseQuery();
    message.idQuery = object.idQuery !== void 0 && object.idQuery !== null ? IdsQuery.fromPartial(object.idQuery) : void 0;
    message.domainQuery = object.domainQuery !== void 0 && object.domainQuery !== null ? DomainsQuery.fromPartial(object.domainQuery) : void 0;
    return message;
  }
};
function createBaseIdsQuery() {
  return { ids: [] };
}
const IdsQuery = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    for (const v of message.ids) {
      writer.uint32(10).string(v);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseIdsQuery();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.ids.push(reader.string());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { ids: globalThis.Array.isArray(object?.ids) ? object.ids.map((e) => globalThis.String(e)) : [] };
  },
  toJSON(message) {
    const obj = {};
    if (message.ids?.length) {
      obj.ids = message.ids;
    }
    return obj;
  },
  create(base) {
    return IdsQuery.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseIdsQuery();
    message.ids = object.ids?.map((e) => e) || [];
    return message;
  }
};
function createBaseDomainsQuery() {
  return { domains: [] };
}
const DomainsQuery = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    for (const v of message.domains) {
      writer.uint32(10).string(v);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseDomainsQuery();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.domains.push(reader.string());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      domains: globalThis.Array.isArray(object?.domains) ? object.domains.map((e) => globalThis.String(e)) : []
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.domains?.length) {
      obj.domains = message.domains;
    }
    return obj;
  },
  create(base) {
    return DomainsQuery.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseDomainsQuery();
    message.domains = object.domains?.map((e) => e) || [];
    return message;
  }
};
function createBaseDomain() {
  return { details: void 0, domain: "", primary: false, generated: false };
}
const Domain = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.details !== void 0) {
      import_object.ObjectDetails.encode(message.details, writer.uint32(10).fork()).join();
    }
    if (message.domain !== "") {
      writer.uint32(18).string(message.domain);
    }
    if (message.primary !== false) {
      writer.uint32(24).bool(message.primary);
    }
    if (message.generated !== false) {
      writer.uint32(32).bool(message.generated);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseDomain();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.details = import_object.ObjectDetails.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.domain = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }
          message.primary = reader.bool();
          continue;
        }
        case 4: {
          if (tag !== 32) {
            break;
          }
          message.generated = reader.bool();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      details: isSet(object.details) ? import_object.ObjectDetails.fromJSON(object.details) : void 0,
      domain: isSet(object.domain) ? globalThis.String(object.domain) : "",
      primary: isSet(object.primary) ? globalThis.Boolean(object.primary) : false,
      generated: isSet(object.generated) ? globalThis.Boolean(object.generated) : false
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.details !== void 0) {
      obj.details = import_object.ObjectDetails.toJSON(message.details);
    }
    if (message.domain !== "") {
      obj.domain = message.domain;
    }
    if (message.primary !== false) {
      obj.primary = message.primary;
    }
    if (message.generated !== false) {
      obj.generated = message.generated;
    }
    return obj;
  },
  create(base) {
    return Domain.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseDomain();
    message.details = object.details !== void 0 && object.details !== null ? import_object.ObjectDetails.fromPartial(object.details) : void 0;
    message.domain = object.domain ?? "";
    message.primary = object.primary ?? false;
    message.generated = object.generated ?? false;
    return message;
  }
};
function createBaseDomainSearchQuery() {
  return { domainQuery: void 0, generatedQuery: void 0, primaryQuery: void 0 };
}
const DomainSearchQuery = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.domainQuery !== void 0) {
      DomainQuery.encode(message.domainQuery, writer.uint32(10).fork()).join();
    }
    if (message.generatedQuery !== void 0) {
      DomainGeneratedQuery.encode(message.generatedQuery, writer.uint32(18).fork()).join();
    }
    if (message.primaryQuery !== void 0) {
      DomainPrimaryQuery.encode(message.primaryQuery, writer.uint32(26).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseDomainSearchQuery();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.domainQuery = DomainQuery.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.generatedQuery = DomainGeneratedQuery.decode(reader, reader.uint32());
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.primaryQuery = DomainPrimaryQuery.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      domainQuery: isSet(object.domainQuery) ? DomainQuery.fromJSON(object.domainQuery) : void 0,
      generatedQuery: isSet(object.generatedQuery) ? DomainGeneratedQuery.fromJSON(object.generatedQuery) : void 0,
      primaryQuery: isSet(object.primaryQuery) ? DomainPrimaryQuery.fromJSON(object.primaryQuery) : void 0
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.domainQuery !== void 0) {
      obj.domainQuery = DomainQuery.toJSON(message.domainQuery);
    }
    if (message.generatedQuery !== void 0) {
      obj.generatedQuery = DomainGeneratedQuery.toJSON(message.generatedQuery);
    }
    if (message.primaryQuery !== void 0) {
      obj.primaryQuery = DomainPrimaryQuery.toJSON(message.primaryQuery);
    }
    return obj;
  },
  create(base) {
    return DomainSearchQuery.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseDomainSearchQuery();
    message.domainQuery = object.domainQuery !== void 0 && object.domainQuery !== null ? DomainQuery.fromPartial(object.domainQuery) : void 0;
    message.generatedQuery = object.generatedQuery !== void 0 && object.generatedQuery !== null ? DomainGeneratedQuery.fromPartial(object.generatedQuery) : void 0;
    message.primaryQuery = object.primaryQuery !== void 0 && object.primaryQuery !== null ? DomainPrimaryQuery.fromPartial(object.primaryQuery) : void 0;
    return message;
  }
};
function createBaseDomainQuery() {
  return { domain: "", method: 0 };
}
const DomainQuery = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.domain !== "") {
      writer.uint32(10).string(message.domain);
    }
    if (message.method !== 0) {
      writer.uint32(16).int32(message.method);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseDomainQuery();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.domain = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }
          message.method = reader.int32();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      domain: isSet(object.domain) ? globalThis.String(object.domain) : "",
      method: isSet(object.method) ? (0, import_object.textQueryMethodFromJSON)(object.method) : 0
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.domain !== "") {
      obj.domain = message.domain;
    }
    if (message.method !== 0) {
      obj.method = (0, import_object.textQueryMethodToJSON)(message.method);
    }
    return obj;
  },
  create(base) {
    return DomainQuery.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseDomainQuery();
    message.domain = object.domain ?? "";
    message.method = object.method ?? 0;
    return message;
  }
};
function createBaseDomainGeneratedQuery() {
  return { generated: false };
}
const DomainGeneratedQuery = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.generated !== false) {
      writer.uint32(8).bool(message.generated);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseDomainGeneratedQuery();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }
          message.generated = reader.bool();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { generated: isSet(object.generated) ? globalThis.Boolean(object.generated) : false };
  },
  toJSON(message) {
    const obj = {};
    if (message.generated !== false) {
      obj.generated = message.generated;
    }
    return obj;
  },
  create(base) {
    return DomainGeneratedQuery.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseDomainGeneratedQuery();
    message.generated = object.generated ?? false;
    return message;
  }
};
function createBaseDomainPrimaryQuery() {
  return { primary: false };
}
const DomainPrimaryQuery = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.primary !== false) {
      writer.uint32(8).bool(message.primary);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseDomainPrimaryQuery();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }
          message.primary = reader.bool();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { primary: isSet(object.primary) ? globalThis.Boolean(object.primary) : false };
  },
  toJSON(message) {
    const obj = {};
    if (message.primary !== false) {
      obj.primary = message.primary;
    }
    return obj;
  },
  create(base) {
    return DomainPrimaryQuery.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseDomainPrimaryQuery();
    message.primary = object.primary ?? false;
    return message;
  }
};
function createBaseTrustedDomain() {
  return { details: void 0, domain: "" };
}
const TrustedDomain = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.details !== void 0) {
      import_object.ObjectDetails.encode(message.details, writer.uint32(10).fork()).join();
    }
    if (message.domain !== "") {
      writer.uint32(18).string(message.domain);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTrustedDomain();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.details = import_object.ObjectDetails.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.domain = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      details: isSet(object.details) ? import_object.ObjectDetails.fromJSON(object.details) : void 0,
      domain: isSet(object.domain) ? globalThis.String(object.domain) : ""
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.details !== void 0) {
      obj.details = import_object.ObjectDetails.toJSON(message.details);
    }
    if (message.domain !== "") {
      obj.domain = message.domain;
    }
    return obj;
  },
  create(base) {
    return TrustedDomain.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseTrustedDomain();
    message.details = object.details !== void 0 && object.details !== null ? import_object.ObjectDetails.fromPartial(object.details) : void 0;
    message.domain = object.domain ?? "";
    return message;
  }
};
function createBaseTrustedDomainSearchQuery() {
  return { domainQuery: void 0 };
}
const TrustedDomainSearchQuery = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.domainQuery !== void 0) {
      DomainQuery.encode(message.domainQuery, writer.uint32(10).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTrustedDomainSearchQuery();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.domainQuery = DomainQuery.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { domainQuery: isSet(object.domainQuery) ? DomainQuery.fromJSON(object.domainQuery) : void 0 };
  },
  toJSON(message) {
    const obj = {};
    if (message.domainQuery !== void 0) {
      obj.domainQuery = DomainQuery.toJSON(message.domainQuery);
    }
    return obj;
  },
  create(base) {
    return TrustedDomainSearchQuery.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseTrustedDomainSearchQuery();
    message.domainQuery = object.domainQuery !== void 0 && object.domainQuery !== null ? DomainQuery.fromPartial(object.domainQuery) : void 0;
    return message;
  }
};
function isSet(value) {
  return value !== null && value !== void 0;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  Domain,
  DomainFieldName,
  DomainGeneratedQuery,
  DomainPrimaryQuery,
  DomainQuery,
  DomainSearchQuery,
  DomainsQuery,
  FieldName,
  IdsQuery,
  Instance,
  InstanceDetail,
  Query,
  State,
  TrustedDomain,
  TrustedDomainSearchQuery,
  domainFieldNameFromJSON,
  domainFieldNameToJSON,
  fieldNameFromJSON,
  fieldNameToJSON,
  protobufPackage,
  stateFromJSON,
  stateToJSON
});
//# sourceMappingURL=instance.js.map