@ragnaraven/zitadel-node-dual/dist/api/generated/zitadel/resources/object/v3alpha/object.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 __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);
var object_exports = {};
__export(object_exports, {
  Details: () => Details,
  ListDetails: () => ListDetails,
  SearchQuery: () => SearchQuery,
  TextFilterMethod: () => TextFilterMethod,
  protobufPackage: () => protobufPackage,
  textFilterMethodFromJSON: () => textFilterMethodFromJSON,
  textFilterMethodToJSON: () => textFilterMethodToJSON
});
module.exports = __toCommonJS(object_exports);
var import_wire = require("@bufbuild/protobuf/wire");
var import_long = __toESM(require("long"));
var import_timestamp = require("../../../../google/protobuf/timestamp.js");
var import_object = require("../../../object/v3alpha/object.js");
const protobufPackage = "zitadel.resources.object.v3alpha";
var TextFilterMethod = /* @__PURE__ */ ((TextFilterMethod2) => {
  TextFilterMethod2[TextFilterMethod2["TEXT_FILTER_METHOD_EQUALS"] = 0] = "TEXT_FILTER_METHOD_EQUALS";
  TextFilterMethod2[TextFilterMethod2["TEXT_FILTER_METHOD_EQUALS_IGNORE_CASE"] = 1] = "TEXT_FILTER_METHOD_EQUALS_IGNORE_CASE";
  TextFilterMethod2[TextFilterMethod2["TEXT_FILTER_METHOD_STARTS_WITH"] = 2] = "TEXT_FILTER_METHOD_STARTS_WITH";
  TextFilterMethod2[TextFilterMethod2["TEXT_FILTER_METHOD_STARTS_WITH_IGNORE_CASE"] = 3] = "TEXT_FILTER_METHOD_STARTS_WITH_IGNORE_CASE";
  TextFilterMethod2[TextFilterMethod2["TEXT_FILTER_METHOD_CONTAINS"] = 4] = "TEXT_FILTER_METHOD_CONTAINS";
  TextFilterMethod2[TextFilterMethod2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
  return TextFilterMethod2;
})(TextFilterMethod || {});
function textFilterMethodFromJSON(object) {
  switch (object) {
    case 0:
    case "TEXT_FILTER_METHOD_EQUALS":
      return 0 /* TEXT_FILTER_METHOD_EQUALS */;
    case 1:
    case "TEXT_FILTER_METHOD_EQUALS_IGNORE_CASE":
      return 1 /* TEXT_FILTER_METHOD_EQUALS_IGNORE_CASE */;
    case 2:
    case "TEXT_FILTER_METHOD_STARTS_WITH":
      return 2 /* TEXT_FILTER_METHOD_STARTS_WITH */;
    case 3:
    case "TEXT_FILTER_METHOD_STARTS_WITH_IGNORE_CASE":
      return 3 /* TEXT_FILTER_METHOD_STARTS_WITH_IGNORE_CASE */;
    case 4:
    case "TEXT_FILTER_METHOD_CONTAINS":
      return 4 /* TEXT_FILTER_METHOD_CONTAINS */;
    case -1:
    case "UNRECOGNIZED":
    default:
      return -1 /* UNRECOGNIZED */;
  }
}
function textFilterMethodToJSON(object) {
  switch (object) {
    case 0 /* TEXT_FILTER_METHOD_EQUALS */:
      return "TEXT_FILTER_METHOD_EQUALS";
    case 1 /* TEXT_FILTER_METHOD_EQUALS_IGNORE_CASE */:
      return "TEXT_FILTER_METHOD_EQUALS_IGNORE_CASE";
    case 2 /* TEXT_FILTER_METHOD_STARTS_WITH */:
      return "TEXT_FILTER_METHOD_STARTS_WITH";
    case 3 /* TEXT_FILTER_METHOD_STARTS_WITH_IGNORE_CASE */:
      return "TEXT_FILTER_METHOD_STARTS_WITH_IGNORE_CASE";
    case 4 /* TEXT_FILTER_METHOD_CONTAINS */:
      return "TEXT_FILTER_METHOD_CONTAINS";
    case -1 /* UNRECOGNIZED */:
    default:
      return "UNRECOGNIZED";
  }
}
function createBaseDetails() {
  return { id: "", created: void 0, changed: void 0, owner: void 0 };
}
const Details = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    if (message.created !== void 0) {
      import_timestamp.Timestamp.encode(toTimestamp(message.created), writer.uint32(26).fork()).join();
    }
    if (message.changed !== void 0) {
      import_timestamp.Timestamp.encode(toTimestamp(message.changed), writer.uint32(34).fork()).join();
    }
    if (message.owner !== void 0) {
      import_object.Owner.encode(message.owner, writer.uint32(42).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 = createBaseDetails();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.id = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.created = fromTimestamp(import_timestamp.Timestamp.decode(reader, reader.uint32()));
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }
          message.changed = fromTimestamp(import_timestamp.Timestamp.decode(reader, reader.uint32()));
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }
          message.owner = import_object.Owner.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) : "",
      created: isSet(object.created) ? fromJsonTimestamp(object.created) : void 0,
      changed: isSet(object.changed) ? fromJsonTimestamp(object.changed) : void 0,
      owner: isSet(object.owner) ? import_object.Owner.fromJSON(object.owner) : void 0
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.id !== "") {
      obj.id = message.id;
    }
    if (message.created !== void 0) {
      obj.created = message.created.toISOString();
    }
    if (message.changed !== void 0) {
      obj.changed = message.changed.toISOString();
    }
    if (message.owner !== void 0) {
      obj.owner = import_object.Owner.toJSON(message.owner);
    }
    return obj;
  },
  create(base) {
    return Details.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseDetails();
    message.id = object.id ?? "";
    message.created = object.created ?? void 0;
    message.changed = object.changed ?? void 0;
    message.owner = object.owner !== void 0 && object.owner !== null ? import_object.Owner.fromPartial(object.owner) : void 0;
    return message;
  }
};
function createBaseSearchQuery() {
  return { offset: import_long.default.UZERO, limit: 0, desc: false };
}
const SearchQuery = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (!message.offset.equals(import_long.default.UZERO)) {
      writer.uint32(8).uint64(message.offset.toString());
    }
    if (message.limit !== 0) {
      writer.uint32(16).uint32(message.limit);
    }
    if (message.desc !== false) {
      writer.uint32(24).bool(message.desc);
    }
    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 = createBaseSearchQuery();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }
          message.offset = import_long.default.fromString(reader.uint64().toString(), true);
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }
          message.limit = reader.uint32();
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }
          message.desc = reader.bool();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      offset: isSet(object.offset) ? import_long.default.fromValue(object.offset) : import_long.default.UZERO,
      limit: isSet(object.limit) ? globalThis.Number(object.limit) : 0,
      desc: isSet(object.desc) ? globalThis.Boolean(object.desc) : false
    };
  },
  toJSON(message) {
    const obj = {};
    if (!message.offset.equals(import_long.default.UZERO)) {
      obj.offset = (message.offset || import_long.default.UZERO).toString();
    }
    if (message.limit !== 0) {
      obj.limit = Math.round(message.limit);
    }
    if (message.desc !== false) {
      obj.desc = message.desc;
    }
    return obj;
  },
  create(base) {
    return SearchQuery.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseSearchQuery();
    message.offset = object.offset !== void 0 && object.offset !== null ? import_long.default.fromValue(object.offset) : import_long.default.UZERO;
    message.limit = object.limit ?? 0;
    message.desc = object.desc ?? false;
    return message;
  }
};
function createBaseListDetails() {
  return { appliedLimit: import_long.default.UZERO, totalResult: import_long.default.UZERO, timestamp: void 0 };
}
const ListDetails = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (!message.appliedLimit.equals(import_long.default.UZERO)) {
      writer.uint32(8).uint64(message.appliedLimit.toString());
    }
    if (!message.totalResult.equals(import_long.default.UZERO)) {
      writer.uint32(16).uint64(message.totalResult.toString());
    }
    if (message.timestamp !== void 0) {
      import_timestamp.Timestamp.encode(toTimestamp(message.timestamp), 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 = createBaseListDetails();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }
          message.appliedLimit = import_long.default.fromString(reader.uint64().toString(), true);
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }
          message.totalResult = import_long.default.fromString(reader.uint64().toString(), true);
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.timestamp = fromTimestamp(import_timestamp.Timestamp.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      appliedLimit: isSet(object.appliedLimit) ? import_long.default.fromValue(object.appliedLimit) : import_long.default.UZERO,
      totalResult: isSet(object.totalResult) ? import_long.default.fromValue(object.totalResult) : import_long.default.UZERO,
      timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : void 0
    };
  },
  toJSON(message) {
    const obj = {};
    if (!message.appliedLimit.equals(import_long.default.UZERO)) {
      obj.appliedLimit = (message.appliedLimit || import_long.default.UZERO).toString();
    }
    if (!message.totalResult.equals(import_long.default.UZERO)) {
      obj.totalResult = (message.totalResult || import_long.default.UZERO).toString();
    }
    if (message.timestamp !== void 0) {
      obj.timestamp = message.timestamp.toISOString();
    }
    return obj;
  },
  create(base) {
    return ListDetails.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseListDetails();
    message.appliedLimit = object.appliedLimit !== void 0 && object.appliedLimit !== null ? import_long.default.fromValue(object.appliedLimit) : import_long.default.UZERO;
    message.totalResult = object.totalResult !== void 0 && object.totalResult !== null ? import_long.default.fromValue(object.totalResult) : import_long.default.UZERO;
    message.timestamp = object.timestamp ?? void 0;
    return message;
  }
};
function toTimestamp(date) {
  const seconds = numberToLong(Math.trunc(date.getTime() / 1e3));
  const nanos = date.getTime() % 1e3 * 1e6;
  return { seconds, nanos };
}
function fromTimestamp(t) {
  let millis = (t.seconds.toNumber() || 0) * 1e3;
  millis += (t.nanos || 0) / 1e6;
  return new globalThis.Date(millis);
}
function fromJsonTimestamp(o) {
  if (o instanceof globalThis.Date) {
    return o;
  } else if (typeof o === "string") {
    return new globalThis.Date(o);
  } else {
    return fromTimestamp(import_timestamp.Timestamp.fromJSON(o));
  }
}
function numberToLong(number) {
  return import_long.default.fromNumber(number);
}
function isSet(value) {
  return value !== null && value !== void 0;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  Details,
  ListDetails,
  SearchQuery,
  TextFilterMethod,
  protobufPackage,
  textFilterMethodFromJSON,
  textFilterMethodToJSON
});
//# sourceMappingURL=object.js.map