@or-sdk/library-types-v2 6.0.6 → 6.0.8

package/dist/cjs/index.js

@@ -1306,12 +1306,19 @@ In case this error is unexpected for you, please report it in https://github.com
       updatedAt: "updatedAt",
       version: "version",
       versionInt: "versionInt",
+      prerelease: "prerelease",
       type: "type",
       servingType: "servingType",
       label: "label",
       description: "description",
       sourceRevisionId: "sourceRevisionId"
     };
+    exports.Prisma.PackageReleaseDataScalarFieldEnum = {
+      revisionId: "revisionId",
+      data: "data",
+      createdAt: "createdAt",
+      updatedAt: "updatedAt"
+    };
     exports.Prisma.PackageStatusDetailsSystemScalarFieldEnum = {
       id: "id",
       status: "status",
@@ -1428,6 +1435,9 @@ In case this error is unexpected for you, please report it in https://github.com
       description: "description",
       sourceRevisionId: "sourceRevisionId"
     };
+    exports.Prisma.PackageReleaseDataOrderByRelevanceFieldEnum = {
+      revisionId: "revisionId"
+    };
     exports.Prisma.PackageStatusDetailsSystemOrderByRelevanceFieldEnum = {
       packageReleaseRevisionId: "packageReleaseRevisionId"
     };
@@ -1509,6 +1519,7 @@ In case this error is unexpected for you, please report it in https://github.com
       Category: "Category",
       Package: "Package",
       PackageRelease: "PackageRelease",
+      PackageReleaseData: "PackageReleaseData",
       PackageStatusDetailsSystem: "PackageStatusDetailsSystem",
       PackageStatusDetailsRelease: "PackageStatusDetailsRelease",
       PackageDependencies: "PackageDependencies",
@@ -5429,648 +5440,365 @@ var require_lib = __commonJS({
   }
 });
 
-// ../../node_modules/nestjs-zod/dist/z.js
+// ../prisma/node_modules/nestjs-zod/dist/z.js
 var require_z = __commonJS({
-  "../../node_modules/nestjs-zod/dist/z.js"(exports) {
+  "../prisma/node_modules/nestjs-zod/dist/z.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    var zod = require_lib();
-    function _interopNamespace(e) {
-      if (e && e.__esModule)
-        return e;
-      var n = /* @__PURE__ */ Object.create(null);
-      if (e) {
-        Object.keys(e).forEach(function(k) {
-          if (k !== "default") {
-            var d = Object.getOwnPropertyDescriptor(e, k);
-            Object.defineProperty(n, k, d.get ? d : {
-              enumerable: true,
-              get: function() {
-                return e[k];
-              }
-            });
-          }
-        });
-      }
-      n["default"] = e;
-      return Object.freeze(n);
-    }
-    function _mergeNamespaces(n, m) {
-      m.forEach(function(e) {
-        e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
-          if (k !== "default" && !(k in n)) {
-            var d = Object.getOwnPropertyDescriptor(e, k);
-            Object.defineProperty(n, k, d.get ? d : {
-              enumerable: true,
-              get: function() {
-                return e[k];
-              }
-            });
+    var e = require_lib();
+    function t(e2) {
+      if (e2 && e2.__esModule)
+        return e2;
+      var t2 = /* @__PURE__ */ Object.create(null);
+      return e2 && Object.keys(e2).forEach(function(r2) {
+        if ("default" !== r2) {
+          var s2 = Object.getOwnPropertyDescriptor(e2, r2);
+          Object.defineProperty(t2, r2, s2.get ? s2 : { enumerable: true, get: function() {
+            return e2[r2];
+          } });
+        }
+      }), t2.default = e2, Object.freeze(t2);
+    }
+    function r(e2, t2) {
+      return t2.forEach(function(t3) {
+        t3 && "string" != typeof t3 && !Array.isArray(t3) && Object.keys(t3).forEach(function(r2) {
+          if ("default" !== r2 && !(r2 in e2)) {
+            var s2 = Object.getOwnPropertyDescriptor(t3, r2);
+            Object.defineProperty(e2, r2, s2.get ? s2 : { enumerable: true, get: function() {
+              return t3[r2];
+            } });
           }
         });
-      });
-      return Object.freeze(n);
-    }
-    var zod__namespace = /* @__PURE__ */ _interopNamespace(zod);
-    var CUSTOM_ISSUE_CODE = "custom";
-    function isNestJsZodIssue(issue) {
-      var _a;
-      return issue.code === CUSTOM_ISSUE_CODE && ((_a = issue.params) == null ? void 0 : _a.isNestJsZod);
-    }
-    function composeMappers(mappers) {
-      return (issue) => {
-        for (const mapper2 of mappers) {
-          const result = mapper2(issue);
-          if (!result.matched)
-            continue;
-          return result;
-        }
-        return { matched: false };
-      };
-    }
-    function createCustomMapper(map) {
-      return (issue) => {
-        if (!isNestJsZodIssue(issue))
-          return { matched: false };
-        const result = map(issue.params);
-        if (!result.matched)
+      }), Object.freeze(e2);
+    }
+    var s = t(e);
+    function a(e2) {
+      return (t2) => {
+        if (!function(e3) {
+          var t3;
+          return "custom" === e3.code && (null == (t3 = e3.params) ? void 0 : t3.isNestJsZod);
+        }(t2))
           return { matched: false };
-        return result;
+        const r2 = e2(t2.params);
+        return r2.matched ? r2 : { matched: false };
       };
     }
-    function createMinMaxMapper(valueType, map) {
-      return (issue) => {
-        if (issue.code !== zod.ZodIssueCode.too_small && issue.code !== zod.ZodIssueCode.too_big) {
+    function n(t2, r2) {
+      return (s2) => {
+        if (s2.code !== e.ZodIssueCode.too_small && s2.code !== e.ZodIssueCode.too_big)
           return { matched: false };
-        }
-        if (issue.type !== valueType) {
+        if (s2.type !== t2)
           return { matched: false };
-        }
-        const result = map(issue);
-        if (!result.matched)
-          return { matched: false };
-        return result;
+        const a2 = r2(s2);
+        return a2.matched ? a2 : { matched: false };
       };
     }
-    var dateStringCustom = createCustomMapper((params) => {
-      if (params.code === "invalid_date_string") {
-        const message = `Invalid string, expected it to be a valid date`;
-        return { matched: true, message };
+    var i = a((e2) => {
+      if ("invalid_date_string" === e2.code) {
+        return { matched: true, message: "Invalid string, expected it to be a valid date" };
       }
-      if (params.code === "invalid_date_string_format") {
-        const mapper2 = {
-          "date": 'YYYY-MM-DD (RFC3339 "full-date")',
-          "date-time": 'YYYY-MM-DDTHH:mm:ssZ (RFC3339 "date-time")'
-        };
-        const readable = mapper2[params.expected];
-        const message = `Invalid date, expected it to match ${readable}`;
-        return { matched: true, message };
-      }
-      if (params.code === "invalid_date_string_direction") {
-        const message = `Invalid date, expected it to be the ${params.expected}`;
-        return { matched: true, message };
-      }
-      if (params.code === "invalid_date_string_day") {
-        const mapper2 = {
-          weekDay: "week day",
-          weekend: "weekend"
-        };
-        const readable = mapper2[params.expected];
-        const message = `Invalid date, expected it to be a ${readable}`;
-        return { matched: true, message };
+      if ("invalid_date_string_format" === e2.code) {
+        return { matched: true, message: `Invalid date, expected it to match ${{ date: 'YYYY-MM-DD (RFC3339 "full-date")', "date-time": 'YYYY-MM-DDTHH:mm:ssZ (RFC3339 "date-time")' }[e2.expected]}` };
+      }
+      if ("invalid_date_string_direction" === e2.code) {
+        return { matched: true, message: `Invalid date, expected it to be the ${e2.expected}` };
+      }
+      if ("invalid_date_string_day" === e2.code) {
+        return { matched: true, message: `Invalid date, expected it to be a ${{ weekDay: "week day", weekend: "weekend" }[e2.expected]}` };
       }
       return { matched: false };
     });
-    var dateStringYearMinMax = createMinMaxMapper("date_string_year", (issue) => {
-      if (issue.code === zod.ZodIssueCode.too_small) {
-        const appendix = issue.inclusive ? "or equal to " : "";
-        const message = `Year must be greater than ${appendix}${issue.minimum}`;
-        return { matched: true, message };
+    var o = n("date_string_year", (t2) => {
+      if (t2.code === e.ZodIssueCode.too_small) {
+        return { matched: true, message: `Year must be greater than ${t2.inclusive ? "or equal to " : ""}${t2.minimum}` };
       }
-      if (issue.code === zod.ZodIssueCode.too_big) {
-        const appendix = issue.inclusive ? "or equal to " : "";
-        const message = `Year must be less than ${appendix}${issue.maximum}`;
-        return { matched: true, message };
+      if (t2.code === e.ZodIssueCode.too_big) {
+        return { matched: true, message: `Year must be less than ${t2.inclusive ? "or equal to " : ""}${t2.maximum}` };
       }
       return { matched: false };
     });
-    var passwordCustom = createCustomMapper((params) => {
-      if (params.code === "invalid_password_no_digit") {
-        const message = `Password must contain at least one digit`;
-        return { matched: true, message };
+    var d = a((e2) => {
+      if ("invalid_password_no_digit" === e2.code) {
+        return { matched: true, message: "Password must contain at least one digit" };
       }
-      if (params.code === "invalid_password_no_lowercase") {
-        const message = `Password must contain at least one lowercase letter`;
-        return { matched: true, message };
+      if ("invalid_password_no_lowercase" === e2.code) {
+        return { matched: true, message: "Password must contain at least one lowercase letter" };
       }
-      if (params.code === "invalid_password_no_uppercase") {
-        const message = `Password must contain at least one uppercase letter`;
-        return { matched: true, message };
+      if ("invalid_password_no_uppercase" === e2.code) {
+        return { matched: true, message: "Password must contain at least one uppercase letter" };
       }
-      if (params.code === "invalid_password_no_special") {
-        const message = `Password must contain at least one special symbol`;
-        return { matched: true, message };
+      if ("invalid_password_no_special" === e2.code) {
+        return { matched: true, message: "Password must contain at least one special symbol" };
       }
       return { matched: false };
     });
-    var passwordMinMax = createMinMaxMapper("password", (issue) => {
-      if (issue.code === zod.ZodIssueCode.too_small) {
-        const appendix = issue.inclusive ? "or equal to " : "";
-        const message = `Password length must be greater than ${appendix}${issue.minimum}`;
-        return { matched: true, message };
+    var c = n("password", (t2) => {
+      if (t2.code === e.ZodIssueCode.too_small) {
+        return { matched: true, message: `Password length must be greater than ${t2.inclusive ? "or equal to " : ""}${t2.minimum}` };
       }
-      if (issue.code === zod.ZodIssueCode.too_big) {
-        const appendix = issue.inclusive ? "or equal to " : "";
-        const message = `Password length must be less than ${appendix}${issue.maximum}`;
-        return { matched: true, message };
+      if (t2.code === e.ZodIssueCode.too_big) {
+        return { matched: true, message: `Password length must be less than ${t2.inclusive ? "or equal to " : ""}${t2.maximum}` };
       }
       return { matched: false };
     });
-    var mapper = composeMappers([
-      dateStringCustom,
-      dateStringYearMinMax,
-      passwordCustom,
-      passwordMinMax
-    ]);
-    var extendedErrorMap = (issue, context) => {
-      const result = mapper(issue);
-      if (result.matched) {
-        return { message: result.message };
+    var u = (l = [i, o, d, c], (e2) => {
+      for (const t2 of l) {
+        const r2 = t2(e2);
+        if (r2.matched)
+          return r2;
       }
-      return zod.defaultErrorMap(issue, context);
+      return { matched: false };
+    });
+    var l;
+    var m = (t2, r2) => {
+      const s2 = u(t2);
+      return s2.matched ? { message: s2.message } : e.defaultErrorMap(t2, r2);
     };
-    function setExtendedErrorMap(map) {
-      zod.setErrorMap(map);
+    function p(t2) {
+      e.setErrorMap(t2);
     }
-    setExtendedErrorMap(extendedErrorMap);
-    function from(schema) {
-      return schema;
+    function f(e2) {
+      return e2;
     }
-    var literal = zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean()]);
-    var DEFAULT_MESSAGE = "Expected value to be a JSON-serializable";
-    var json = (message = DEFAULT_MESSAGE) => {
-      const schema = zod.z.lazy(() => zod.z.union([literal, zod.z.array(schema), zod.z.record(schema)], {
-        invalid_type_error: message
-      }));
-      return schema;
+    p(m);
+    var g = e.z.union([e.z.string(), e.z.number(), e.z.boolean()]);
+    var h = (t2 = "Expected value to be a JSON-serializable") => {
+      const r2 = e.z.lazy(() => e.z.union([g, e.z.array(r2), e.z.record(r2)], { invalid_type_error: t2 }));
+      return r2;
     };
-    function addIssueToContextExtended(context, issueData) {
-      zod.addIssueToContext(context, issueData);
+    function _(t2, r2) {
+      e.addIssueToContext(t2, r2);
     }
-    function normalizeErrorMessage(message) {
-      if (typeof message === "string")
-        return { message };
-      return message;
+    function y(e2) {
+      return "string" == typeof e2 ? { message: e2 } : e2;
     }
-    function processCreateParams2(params) {
-      if (!params)
+    function v(e2) {
+      if (!e2)
         return {};
-      const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;
-      if (errorMap2 && (invalid_type_error || required_error)) {
+      const { errorMap: t2, invalid_type_error: r2, required_error: s2, description: a2 } = e2;
+      if (t2 && (r2 || s2))
         throw new Error(`Can't use "invalid" or "required" in conjunction with custom error map.`);
-      }
-      if (errorMap2)
-        return { errorMap: errorMap2, description };
-      const customMap = (issue, context) => {
-        if (issue.code !== "invalid_type")
-          return { message: context.defaultError };
-        if (typeof context.data === "undefined" && required_error)
-          return { message: required_error };
-        if (params.invalid_type_error)
-          return { message: params.invalid_type_error };
-        return { message: context.defaultError };
-      };
-      return { errorMap: customMap, description };
-    }
-    function findCheck(checks, kind) {
-      return checks.find((check) => check.kind === kind);
-    }
-    function hasCheck(checks, kind) {
-      return Boolean(findCheck(checks, kind));
-    }
-    var ZodFirstPartyTypeKindExtended = /* @__PURE__ */ ((ZodFirstPartyTypeKindExtended2) => {
-      ZodFirstPartyTypeKindExtended2["ZodDateString"] = "ZodDateString";
-      ZodFirstPartyTypeKindExtended2["ZodPassword"] = "ZodPassword";
-      return ZodFirstPartyTypeKindExtended2;
-    })(ZodFirstPartyTypeKindExtended || {});
-    var __defProp$1 = Object.defineProperty;
-    var __defProps$1 = Object.defineProperties;
-    var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
-    var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
-    var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
-    var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
-    var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-    var __spreadValues$1 = (a, b) => {
-      for (var prop in b || (b = {}))
-        if (__hasOwnProp$1.call(b, prop))
-          __defNormalProp$1(a, prop, b[prop]);
-      if (__getOwnPropSymbols$1)
-        for (var prop of __getOwnPropSymbols$1(b)) {
-          if (__propIsEnum$1.call(b, prop))
-            __defNormalProp$1(a, prop, b[prop]);
-        }
-      return a;
-    };
-    var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
-    var formatToRegex = {
-      "date": /^\d{4}-\d{2}-\d{2}$/,
-      "date-time": /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(|\.\d{3})(Z|[+-]\d{2}:\d{2})$/
-    };
-    var _ZodDateString = class extends zod.ZodType {
-      _parse(input) {
-        const parsedType = this._getType(input);
-        const context = this._getOrReturnCtx(input);
-        if (parsedType !== zod.ZodParsedType.string) {
-          addIssueToContextExtended(context, {
-            code: zod.ZodIssueCode.invalid_type,
-            expected: zod.ZodParsedType.string,
-            received: context.parsedType
-          });
-          return zod.INVALID;
-        }
-        const date = new Date(input.data);
-        if (Number.isNaN(date.getTime())) {
-          addIssueToContextExtended(context, {
-            code: zod.ZodIssueCode.custom,
-            message: "Invalid date string",
-            params: {
-              isNestJsZod: true,
-              code: "invalid_date_string"
-            }
-          });
-          return zod.INVALID;
-        }
-        const status = new zod.ParseStatus();
-        for (const check of this._def.checks) {
-          if (check.kind === "format") {
-            const valid = check.regex.test(input.data);
-            if (valid)
+      if (t2)
+        return { errorMap: t2, description: a2 };
+      return { errorMap: (t3, r3) => "invalid_type" !== t3.code ? { message: r3.defaultError } : void 0 === r3.data && s2 ? { message: s2 } : e2.invalid_type_error ? { message: e2.invalid_type_error } : { message: r3.defaultError }, description: a2 };
+    }
+    function k(e2, t2) {
+      return e2.find((e3) => e3.kind === t2);
+    }
+    var w = ((e2) => (e2.ZodDateString = "ZodDateString", e2.ZodPassword = "ZodPassword", e2))(w || {});
+    var b = Object.defineProperty;
+    var x = Object.defineProperties;
+    var Z = Object.getOwnPropertyDescriptors;
+    var O = Object.getOwnPropertySymbols;
+    var C = Object.prototype.hasOwnProperty;
+    var P = Object.prototype.propertyIsEnumerable;
+    var I = (e2, t2, r2) => t2 in e2 ? b(e2, t2, { enumerable: true, configurable: true, writable: true, value: r2 }) : e2[t2] = r2;
+    var j = (e2, t2) => {
+      for (var r2 in t2 || (t2 = {}))
+        C.call(t2, r2) && I(e2, r2, t2[r2]);
+      if (O)
+        for (var r2 of O(t2))
+          P.call(t2, r2) && I(e2, r2, t2[r2]);
+      return e2;
+    };
+    var D = { date: /^\d{4}-\d{2}-\d{2}$/, "date-time": /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(|\.\d{3})(Z|[+-]\d{2}:\d{2})$/ };
+    var Y = class extends e.ZodType {
+      _parse(t2) {
+        const r2 = this._getType(t2), s2 = this._getOrReturnCtx(t2);
+        if (r2 !== e.ZodParsedType.string)
+          return _(s2, { code: e.ZodIssueCode.invalid_type, expected: e.ZodParsedType.string, received: s2.parsedType }), e.INVALID;
+        const a2 = new Date(t2.data);
+        if (Number.isNaN(a2.getTime()))
+          return _(s2, { code: e.ZodIssueCode.custom, message: "Invalid date string", params: { isNestJsZod: true, code: "invalid_date_string" } }), e.INVALID;
+        const n2 = new e.ParseStatus();
+        for (const r3 of this._def.checks)
+          if ("format" === r3.kind) {
+            if (r3.regex.test(t2.data))
               continue;
-            addIssueToContextExtended(context, {
-              code: zod.ZodIssueCode.custom,
-              message: check.message,
-              params: {
-                isNestJsZod: true,
-                code: "invalid_date_string_format",
-                expected: check.value
-              }
-            });
-            status.dirty();
-          } else if (check.kind === "direction") {
-            const conditions = {
-              past: date < /* @__PURE__ */ new Date(),
-              future: date > /* @__PURE__ */ new Date()
-            };
-            const valid = conditions[check.direction];
-            if (valid)
+            _(s2, { code: e.ZodIssueCode.custom, message: r3.message, params: { isNestJsZod: true, code: "invalid_date_string_format", expected: r3.value } }), n2.dirty();
+          } else if ("direction" === r3.kind) {
+            if ({ past: a2 < /* @__PURE__ */ new Date(), future: a2 > /* @__PURE__ */ new Date() }[r3.direction])
               continue;
-            addIssueToContextExtended(context, {
-              code: zod.ZodIssueCode.custom,
-              message: check.message,
-              params: {
-                isNestJsZod: true,
-                code: "invalid_date_string_direction",
-                expected: check.direction
-              }
-            });
-            status.dirty();
-          } else if (check.kind === "day-type") {
-            const day = date.getDay();
-            const conditions = {
-              weekDay: day !== 0 && day !== 6,
-              weekend: day === 0 || day === 6
-            };
-            const valid = conditions[check.type];
-            if (valid)
+            _(s2, { code: e.ZodIssueCode.custom, message: r3.message, params: { isNestJsZod: true, code: "invalid_date_string_direction", expected: r3.direction } }), n2.dirty();
+          } else if ("day-type" === r3.kind) {
+            const t3 = a2.getDay();
+            if ({ weekDay: 0 !== t3 && 6 !== t3, weekend: 0 === t3 || 6 === t3 }[r3.type])
               continue;
-            addIssueToContextExtended(context, {
-              code: zod.ZodIssueCode.custom,
-              message: check.message,
-              params: {
-                isNestJsZod: true,
-                code: "invalid_date_string_day",
-                expected: check.type
-              }
-            });
-            status.dirty();
-          } else if (check.kind === "minYear") {
-            const valid = date.getFullYear() >= check.value;
-            if (valid)
+            _(s2, { code: e.ZodIssueCode.custom, message: r3.message, params: { isNestJsZod: true, code: "invalid_date_string_day", expected: r3.type } }), n2.dirty();
+          } else if ("minYear" === r3.kind) {
+            if (a2.getFullYear() >= r3.value)
               continue;
-            addIssueToContextExtended(context, {
-              code: zod.ZodIssueCode.too_small,
-              type: "date_string_year",
-              minimum: check.value,
-              inclusive: true,
-              message: check.message
-            });
-            status.dirty();
-          } else if (check.kind === "maxYear") {
-            const valid = date.getFullYear() <= check.value;
-            if (valid)
+            _(s2, { code: e.ZodIssueCode.too_small, type: "date_string_year", minimum: r3.value, inclusive: true, message: r3.message }), n2.dirty();
+          } else if ("maxYear" === r3.kind) {
+            if (a2.getFullYear() <= r3.value)
               continue;
-            addIssueToContextExtended(context, {
-              code: zod.ZodIssueCode.too_big,
-              type: "date_string_year",
-              maximum: check.value,
-              inclusive: true,
-              message: check.message
-            });
-            status.dirty();
+            _(s2, { code: e.ZodIssueCode.too_big, type: "date_string_year", maximum: r3.value, inclusive: true, message: r3.message }), n2.dirty();
           }
-        }
-        return { status: status.value, value: input.data };
+        return { status: n2.value, value: t2.data };
       }
-      _replaceCheck(check) {
-        return new _ZodDateString(__spreadProps$1(__spreadValues$1({}, this._def), {
-          checks: this._def.checks.filter((item) => item.kind !== check.kind).concat(check)
-        }));
+      _replaceCheck(e2) {
+        return new Y((t2 = j({}, this._def), r2 = { checks: this._def.checks.filter((t3) => t3.kind !== e2.kind).concat(e2) }, x(t2, Z(r2))));
+        var t2, r2;
+      }
+      format(e2, t2) {
+        return this._replaceCheck(j({ kind: "format", value: e2, regex: D[e2] }, y(t2)));
+      }
+      past(e2) {
+        return this._replaceCheck(j({ kind: "direction", direction: "past" }, y(e2)));
+      }
+      future(e2) {
+        return this._replaceCheck(j({ kind: "direction", direction: "future" }, y(e2)));
+      }
+      weekDay(e2) {
+        return this._replaceCheck(j({ kind: "day-type", type: "weekDay" }, y(e2)));
+      }
+      weekend(e2) {
+        return this._replaceCheck(j({ kind: "day-type", type: "weekend" }, y(e2)));
+      }
+      minYear(e2, t2) {
+        return this._replaceCheck(j({ kind: "minYear", value: e2 }, y(t2)));
       }
-      format(format, message) {
-        return this._replaceCheck(__spreadValues$1({
-          kind: "format",
-          value: format,
-          regex: formatToRegex[format]
-        }, normalizeErrorMessage(message)));
-      }
-      past(message) {
-        return this._replaceCheck(__spreadValues$1({
-          kind: "direction",
-          direction: "past"
-        }, normalizeErrorMessage(message)));
-      }
-      future(message) {
-        return this._replaceCheck(__spreadValues$1({
-          kind: "direction",
-          direction: "future"
-        }, normalizeErrorMessage(message)));
-      }
-      weekDay(message) {
-        return this._replaceCheck(__spreadValues$1({
-          kind: "day-type",
-          type: "weekDay"
-        }, normalizeErrorMessage(message)));
-      }
-      weekend(message) {
-        return this._replaceCheck(__spreadValues$1({
-          kind: "day-type",
-          type: "weekend"
-        }, normalizeErrorMessage(message)));
-      }
-      minYear(year, message) {
-        return this._replaceCheck(__spreadValues$1({
-          kind: "minYear",
-          value: year
-        }, normalizeErrorMessage(message)));
-      }
-      maxYear(year, message) {
-        return this._replaceCheck(__spreadValues$1({
-          kind: "maxYear",
-          value: year
-        }, normalizeErrorMessage(message)));
+      maxYear(e2, t2) {
+        return this._replaceCheck(j({ kind: "maxYear", value: e2 }, y(t2)));
       }
       cast() {
-        return this.transform((string) => new Date(string));
+        return this.transform((e2) => new Date(e2));
       }
       get format_() {
-        return findCheck(this._def.checks, "format");
+        return k(this._def.checks, "format");
       }
       get isPast() {
-        var _a;
-        return ((_a = findCheck(this._def.checks, "direction")) == null ? void 0 : _a.direction) === "past";
+        var e2;
+        return "past" === (null == (e2 = k(this._def.checks, "direction")) ? void 0 : e2.direction);
       }
       get isFuture() {
-        var _a;
-        return ((_a = findCheck(this._def.checks, "direction")) == null ? void 0 : _a.direction) === "future";
+        var e2;
+        return "future" === (null == (e2 = k(this._def.checks, "direction")) ? void 0 : e2.direction);
       }
       get isWeekDay() {
-        var _a;
-        return ((_a = findCheck(this._def.checks, "day-type")) == null ? void 0 : _a.type) === "weekDay";
+        var e2;
+        return "weekDay" === (null == (e2 = k(this._def.checks, "day-type")) ? void 0 : e2.type);
       }
       get isWeekend() {
-        var _a;
-        return ((_a = findCheck(this._def.checks, "day-type")) == null ? void 0 : _a.type) === "weekend";
+        var e2;
+        return "weekend" === (null == (e2 = k(this._def.checks, "day-type")) ? void 0 : e2.type);
       }
       get minYear_() {
-        return findCheck(this._def.checks, "minYear");
+        return k(this._def.checks, "minYear");
       }
       get maxYear_() {
-        return findCheck(this._def.checks, "maxYear");
-      }
-    };
-    var ZodDateString = _ZodDateString;
-    ZodDateString.create = (params) => {
-      return new _ZodDateString(__spreadValues$1({
-        checks: [
-          {
-            kind: "format",
-            value: "date-time",
-            regex: formatToRegex["date-time"]
-          }
-        ],
-        typeName: ZodFirstPartyTypeKindExtended.ZodDateString
-      }, processCreateParams2(params)));
-    };
-    var dateString = ZodDateString.create;
-    var __defProp2 = Object.defineProperty;
-    var __defProps = Object.defineProperties;
-    var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-    var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-    var __propIsEnum = Object.prototype.propertyIsEnumerable;
-    var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-    var __spreadValues = (a, b) => {
-      for (var prop in b || (b = {}))
-        if (__hasOwnProp2.call(b, prop))
-          __defNormalProp(a, prop, b[prop]);
-      if (__getOwnPropSymbols)
-        for (var prop of __getOwnPropSymbols(b)) {
-          if (__propIsEnum.call(b, prop))
-            __defNormalProp(a, prop, b[prop]);
-        }
-      return a;
-    };
-    var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-    var SYMBOL_KINDS = [
-      "digit",
-      "lowercase",
-      "uppercase",
-      "special"
-    ];
-    var REGEXPS = {
-      digit: /\d/,
-      lowercase: /[a-z]/,
-      uppercase: /[A-Z]/,
-      special: /[!?@#$%^&*{};.,:%№"|\\/()\-_+=<>`~[\]'"]/
-    };
-    function isSymbolCheck(check) {
-      return SYMBOL_KINDS.includes(check.kind);
-    }
-    var _ZodPassword = class extends zod.ZodType {
-      _parse(input) {
-        const parsedType = this._getType(input);
-        const context = this._getOrReturnCtx(input);
-        if (parsedType !== zod.ZodParsedType.string) {
-          addIssueToContextExtended(context, {
-            code: zod.ZodIssueCode.invalid_type,
-            expected: zod.ZodParsedType.string,
-            received: context.parsedType
-          });
-          return zod.INVALID;
-        }
-        const status = new zod.ParseStatus();
-        for (const check of this._def.checks) {
-          if (isSymbolCheck(check)) {
-            const valid = REGEXPS[check.kind].test(input.data);
-            if (valid)
+        return k(this._def.checks, "maxYear");
+      }
+    };
+    var E = Y;
+    E.create = (e2) => new Y(j({ checks: [{ kind: "format", value: "date-time", regex: D["date-time"] }], typeName: w.ZodDateString }, v(e2)));
+    var $ = E.create;
+    var T = Object.defineProperty;
+    var z2 = Object.defineProperties;
+    var M = Object.getOwnPropertyDescriptors;
+    var N = Object.getOwnPropertySymbols;
+    var L = Object.prototype.hasOwnProperty;
+    var S = Object.prototype.propertyIsEnumerable;
+    var F = (e2, t2, r2) => t2 in e2 ? T(e2, t2, { enumerable: true, configurable: true, writable: true, value: r2 }) : e2[t2] = r2;
+    var q = (e2, t2) => {
+      for (var r2 in t2 || (t2 = {}))
+        L.call(t2, r2) && F(e2, r2, t2[r2]);
+      if (N)
+        for (var r2 of N(t2))
+          S.call(t2, r2) && F(e2, r2, t2[r2]);
+      return e2;
+    };
+    var A = ["digit", "lowercase", "uppercase", "special"];
+    var J = { digit: /\d/, lowercase: /[a-z]/, uppercase: /[A-Z]/, special: /[!?@#$%^&*{};.,:%№"|\\/()-_+=<>`~[\]'"]/ };
+    function R(e2) {
+      return A.includes(e2.kind);
+    }
+    var V = class extends e.ZodType {
+      _parse(t2) {
+        const r2 = this._getType(t2), s2 = this._getOrReturnCtx(t2);
+        if (r2 !== e.ZodParsedType.string)
+          return _(s2, { code: e.ZodIssueCode.invalid_type, expected: e.ZodParsedType.string, received: s2.parsedType }), e.INVALID;
+        const a2 = new e.ParseStatus();
+        for (const r3 of this._def.checks)
+          if (R(r3)) {
+            if (J[r3.kind].test(t2.data))
               continue;
-            addIssueToContextExtended(context, {
-              code: zod.ZodIssueCode.custom,
-              message: check.message,
-              params: {
-                isNestJsZod: true,
-                code: `invalid_password_no_${check.kind}`
-              }
-            });
-            status.dirty();
-          } else if (check.kind === "minLength") {
-            const valid = input.data.length >= check.value;
-            if (valid)
+            _(s2, { code: e.ZodIssueCode.custom, message: r3.message, params: { isNestJsZod: true, code: `invalid_password_no_${r3.kind}` } }), a2.dirty();
+          } else if ("minLength" === r3.kind) {
+            if (t2.data.length >= r3.value)
               continue;
-            addIssueToContextExtended(context, {
-              code: zod.ZodIssueCode.too_small,
-              type: "password",
-              minimum: check.value,
-              inclusive: true,
-              message: check.message
-            });
-            status.dirty();
-          } else if (check.kind === "maxLength") {
-            const valid = input.data.length <= check.value;
-            if (valid)
+            _(s2, { code: e.ZodIssueCode.too_small, type: "password", minimum: r3.value, inclusive: true, message: r3.message }), a2.dirty();
+          } else if ("maxLength" === r3.kind) {
+            if (t2.data.length <= r3.value)
               continue;
-            addIssueToContextExtended(context, {
-              code: zod.ZodIssueCode.too_big,
-              type: "password",
-              maximum: check.value,
-              inclusive: true,
-              message: check.message
-            });
-            status.dirty();
+            _(s2, { code: e.ZodIssueCode.too_big, type: "password", maximum: r3.value, inclusive: true, message: r3.message }), a2.dirty();
           }
-        }
-        return { status: status.value, value: input.data };
+        return { status: a2.value, value: t2.data };
       }
-      _replaceCheck(check) {
-        return new _ZodPassword(__spreadProps(__spreadValues({}, this._def), {
-          checks: this._def.checks.filter((item) => item.kind !== check.kind).concat(check)
-        }));
+      _replaceCheck(e2) {
+        return new V((t2 = q({}, this._def), r2 = { checks: this._def.checks.filter((t3) => t3.kind !== e2.kind).concat(e2) }, z2(t2, M(r2))));
+        var t2, r2;
       }
       buildFullRegExp() {
-        const lookaheads = [];
-        for (const check of this._def.checks) {
-          if (!isSymbolCheck(check))
+        const e2 = [];
+        for (const t3 of this._def.checks) {
+          if (!R(t3))
             continue;
-          const regex = REGEXPS[check.kind];
-          lookaheads.push(`(?=.*${regex.source})`);
+          const r2 = J[t3.kind];
+          e2.push(`(?=.*${r2.source})`);
         }
-        if (lookaheads.length === 0) {
+        if (0 === e2.length)
           return /^.*$/;
-        }
-        const union = lookaheads.join("");
-        return new RegExp(`^(?:${union}.*)$`);
+        const t2 = e2.join("");
+        return new RegExp(`^(?:${t2}.*)$`);
       }
-      atLeastOne(kind, message) {
-        return this._replaceCheck(__spreadValues({
-          kind
-        }, normalizeErrorMessage(message)));
+      atLeastOne(e2, t2) {
+        return this._replaceCheck(q({ kind: e2 }, y(t2)));
       }
-      min(length, message) {
-        return this._replaceCheck(__spreadValues({
-          kind: "minLength",
-          value: length
-        }, normalizeErrorMessage(message)));
+      min(e2, t2) {
+        return this._replaceCheck(q({ kind: "minLength", value: e2 }, y(t2)));
       }
-      max(length, message) {
-        return this._replaceCheck(__spreadValues({
-          kind: "maxLength",
-          value: length
-        }, normalizeErrorMessage(message)));
+      max(e2, t2) {
+        return this._replaceCheck(q({ kind: "maxLength", value: e2 }, y(t2)));
       }
-      isAtLeastOne(kind) {
-        return hasCheck(this._def.checks, kind);
+      isAtLeastOne(e2) {
+        return function(e3, t2) {
+          return Boolean(k(e3, t2));
+        }(this._def.checks, e2);
       }
       get minLength() {
-        return findCheck(this._def.checks, "minLength");
+        return k(this._def.checks, "minLength");
       }
       get maxLength() {
-        return findCheck(this._def.checks, "maxLength");
+        return k(this._def.checks, "maxLength");
       }
     };
-    var ZodPassword = _ZodPassword;
-    ZodPassword.create = (params) => {
-      return new _ZodPassword(__spreadValues({
-        checks: [],
-        typeName: ZodFirstPartyTypeKindExtended.ZodPassword
-      }, processCreateParams2(params)));
-    };
-    var password = ZodPassword.create;
-    var onlyOverride = /* @__PURE__ */ _mergeNamespaces({
-      __proto__: null,
-      defaultErrorMap: extendedErrorMap,
-      setErrorMap: setExtendedErrorMap,
-      addIssueToContext: addIssueToContextExtended,
-      from,
-      json,
-      ZodDateString,
-      dateString,
-      ZodPassword,
-      password,
-      ZodFirstPartyTypeKindExtended
-    }, [zod__namespace]);
-    exports.ZodDateString = ZodDateString;
-    exports.ZodFirstPartyTypeKindExtended = ZodFirstPartyTypeKindExtended;
-    exports.ZodPassword = ZodPassword;
-    exports.addIssueToContext = addIssueToContextExtended;
-    exports.dateString = dateString;
-    exports.defaultErrorMap = extendedErrorMap;
-    exports.from = from;
-    exports.json = json;
-    exports.password = password;
-    exports.setErrorMap = setExtendedErrorMap;
-    exports.z = onlyOverride;
-    Object.keys(zod).forEach(function(k) {
-      if (k !== "default" && !exports.hasOwnProperty(k))
-        Object.defineProperty(exports, k, {
-          enumerable: true,
-          get: function() {
-            return zod[k];
-          }
-        });
+    var H = V;
+    H.create = (e2) => new V(q({ checks: [], typeName: w.ZodPassword }, v(e2)));
+    var K = H.create;
+    var W = r({ __proto__: null, defaultErrorMap: m, setErrorMap: p, addIssueToContext: _, from: f, json: h, ZodDateString: E, dateString: $, ZodPassword: H, password: K, ZodFirstPartyTypeKindExtended: w }, [s]);
+    exports.ZodDateString = E, exports.ZodFirstPartyTypeKindExtended = w, exports.ZodPassword = H, exports.addIssueToContext = _, exports.dateString = $, exports.defaultErrorMap = m, exports.from = f, exports.json = h, exports.password = K, exports.setErrorMap = p, exports.z = W, Object.keys(e).forEach(function(t2) {
+      "default" === t2 || exports.hasOwnProperty(t2) || Object.defineProperty(exports, t2, { enumerable: true, get: function() {
+        return e[t2];
+      } });
     });
   }
 });
 
-// ../../node_modules/nestjs-zod/dist/dto.js
+// ../prisma/node_modules/nestjs-zod/dist/dto.js
 var require_dto = __commonJS({
-  "../../node_modules/nestjs-zod/dist/dto.js"(exports) {
+  "../prisma/node_modules/nestjs-zod/dist/dto.js"(exports) {
     "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    function createZodDto(schema) {
-      class AugmentedZodDto {
-        static create(input) {
-          return this.schema.parse(input);
+    Object.defineProperty(exports, "__esModule", { value: true }), exports.createZodDto = function(e) {
+      class t {
+        static create(e2) {
+          return this.schema.parse(e2);
         }
       }
-      AugmentedZodDto.isZodDto = true;
-      AugmentedZodDto.schema = schema;
-      return AugmentedZodDto;
-    }
-    function isZodDto(metatype) {
-      return metatype == null ? void 0 : metatype.isZodDto;
-    }
-    exports.createZodDto = createZodDto;
-    exports.isZodDto = isZodDto;
+      return t.isZodDto = true, t.schema = e, t;
+    }, exports.isZodDto = function(e) {
+      return null == e ? void 0 : e.isZodDto;
+    };
   }
 });
 
@@ -6109,23 +5837,23 @@ var require_enums = __commonJS({
       PackageSchemaTypeEnum3["EXTERNAL"] = "EXTERNAL";
       PackageSchemaTypeEnum3["UNKNOWN"] = "UNKNOWN";
     })(PackageSchemaTypeEnum2 || (exports.PackageSchemaTypeEnum = PackageSchemaTypeEnum2 = {}));
-    var PackageStatusDetailsStatusEnum3;
-    (function(PackageStatusDetailsStatusEnum4) {
-      PackageStatusDetailsStatusEnum4["TEST_ONLY"] = "TEST_ONLY";
-      PackageStatusDetailsStatusEnum4["PENDING"] = "PENDING";
-      PackageStatusDetailsStatusEnum4["EXTRACTING"] = "EXTRACTING";
-      PackageStatusDetailsStatusEnum4["UPLOADED"] = "UPLOADED";
-      PackageStatusDetailsStatusEnum4["BETA"] = "BETA";
-      PackageStatusDetailsStatusEnum4["RELEASED"] = "RELEASED";
-      PackageStatusDetailsStatusEnum4["ACCOUNT_BETA"] = "ACCOUNT_BETA";
-      PackageStatusDetailsStatusEnum4["DEPRECATED"] = "DEPRECATED";
-    })(PackageStatusDetailsStatusEnum3 || (exports.PackageStatusDetailsStatusEnum = PackageStatusDetailsStatusEnum3 = {}));
-    var PackageStatusDetailsLevelEnum3;
-    (function(PackageStatusDetailsLevelEnum4) {
-      PackageStatusDetailsLevelEnum4["USER"] = "USER";
-      PackageStatusDetailsLevelEnum4["ACCOUNT"] = "ACCOUNT";
-      PackageStatusDetailsLevelEnum4["PDE"] = "PDE";
-    })(PackageStatusDetailsLevelEnum3 || (exports.PackageStatusDetailsLevelEnum = PackageStatusDetailsLevelEnum3 = {}));
+    var PackageStatusDetailsStatusEnum2;
+    (function(PackageStatusDetailsStatusEnum3) {
+      PackageStatusDetailsStatusEnum3["TEST_ONLY"] = "TEST_ONLY";
+      PackageStatusDetailsStatusEnum3["PENDING"] = "PENDING";
+      PackageStatusDetailsStatusEnum3["EXTRACTING"] = "EXTRACTING";
+      PackageStatusDetailsStatusEnum3["UPLOADED"] = "UPLOADED";
+      PackageStatusDetailsStatusEnum3["BETA"] = "BETA";
+      PackageStatusDetailsStatusEnum3["RELEASED"] = "RELEASED";
+      PackageStatusDetailsStatusEnum3["ACCOUNT_BETA"] = "ACCOUNT_BETA";
+      PackageStatusDetailsStatusEnum3["DEPRECATED"] = "DEPRECATED";
+    })(PackageStatusDetailsStatusEnum2 || (exports.PackageStatusDetailsStatusEnum = PackageStatusDetailsStatusEnum2 = {}));
+    var PackageStatusDetailsLevelEnum2;
+    (function(PackageStatusDetailsLevelEnum3) {
+      PackageStatusDetailsLevelEnum3["USER"] = "USER";
+      PackageStatusDetailsLevelEnum3["ACCOUNT"] = "ACCOUNT";
+      PackageStatusDetailsLevelEnum3["PDE"] = "PDE";
+    })(PackageStatusDetailsLevelEnum2 || (exports.PackageStatusDetailsLevelEnum = PackageStatusDetailsLevelEnum2 = {}));
   }
 });
 
@@ -6663,6 +6391,7 @@ var require_packagerelease = __commonJS({
       updatedAt: z2.date().or(z2.string()),
       version: z2.string(),
       versionInt: z2.string().or(z2.bigint()),
+      prerelease: z2.boolean(),
       type: z2.nativeEnum(enums_1.PackageTypeEnum),
       servingType: z2.string().nullish(),
       label: z2.string(),
@@ -6689,7 +6418,95 @@ var require_packagerelease = __commonJS({
         dependencies: index_1.PackageDependenciesModel.array(),
         statusDetailsSystem: index_1.PackageStatusDetailsSystemModel.array(),
         statusDetailsRelease: index_1.PackageStatusDetailsReleaseModel.array(),
-        sourceRevision: index_1.SourceRevisionModel.nullish()
+        sourceRevision: index_1.SourceRevisionModel.nullish(),
+        packageReleaseData: index_1.PackageReleaseDataModel.nullish()
+      });
+    });
+  }
+});
+
+// ../prisma/dist/generated/zod/packagereleasedata.js
+var require_packagereleasedata = __commonJS({
+  "../prisma/dist/generated/zod/packagereleasedata.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2)
+            if (Object.prototype.hasOwnProperty.call(b2, p))
+              d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    }();
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod)
+          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+            __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PackageReleaseDataModel = exports.PackageReleaseDataDto = exports._PackageReleaseDataModel = void 0;
+    var z2 = __importStar(require_z());
+    var dto_1 = require_dto();
+    var index_1 = require_zod();
+    exports._PackageReleaseDataModel = z2.object({
+      revisionId: z2.string(),
+      data: z2.json(),
+      createdAt: z2.date(),
+      updatedAt: z2.date()
+    });
+    var PackageReleaseDataDto = (
+      /** @class */
+      function(_super) {
+        __extends(PackageReleaseDataDto2, _super);
+        function PackageReleaseDataDto2() {
+          return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return PackageReleaseDataDto2;
+      }((0, dto_1.createZodDto)(exports._PackageReleaseDataModel))
+    );
+    exports.PackageReleaseDataDto = PackageReleaseDataDto;
+    exports.PackageReleaseDataModel = z2.lazy(function() {
+      return exports._PackageReleaseDataModel.extend({
+        packageRelease: index_1.PackageReleaseModel
       });
     });
   }
@@ -7374,6 +7191,7 @@ var require_zod = __commonJS({
     __exportStar(require_category(), exports);
     __exportStar(require_package(), exports);
     __exportStar(require_packagerelease(), exports);
+    __exportStar(require_packagereleasedata(), exports);
     __exportStar(require_packagestatusdetailssystem(), exports);
     __exportStar(require_packagestatusdetailsrelease(), exports);
     __exportStar(require_packagedependencies(), exports);
@@ -11213,15 +11031,18 @@ var PackageMeta = z.intersection(
   z.record(z.any(), z.any())
 ).optional();
 var AddPackageBody = import_library_prisma.prismaZodGenerated._PackageModel.pick({ label: true, description: true, id: true, type: true }).merge(
-  import_library_prisma.prismaZodGenerated._PackageReleaseModel.omit({
-    versionInt: true,
-    sourceRevisionId: true,
-    updatedAt: true,
-    modifiedById: true,
-    createdAt: true,
-    id: true,
-    createdById: true,
-    meta: true
+  import_library_prisma.prismaZodGenerated._PackageReleaseModel.pick({
+    version: true,
+    data: true,
+    membersAccountIds: true,
+    membersUserIds: true,
+    releaseNotesMarkdown: true,
+    revisionId: true,
+    schemaType: true,
+    type: true,
+    servingType: true,
+    label: true,
+    description: true
   }).merge(
     z.object({
       statusDetailsSystem: import_library_prisma.prismaZodGenerated._PackageStatusDetailsSystemModel.pick({ status: true }).optional(),
@@ -11269,9 +11090,13 @@ var ListView = z.object({
   filter: z.any().optional(),
   scope: z.any().optional()
 });
-var PaginationParamsFunc = (orderByEnum = ["updatedAt", "createdAt"]) => z.object({
-  orderBy: z.enum(orderByEnum).default(orderByEnum[0]),
-  order: z.nativeEnum(import_library_prisma2.Prisma.SortOrder).default(import_library_prisma2.Prisma.SortOrder.desc),
+var PaginationParamsFunc = ({
+  orderByEnum = ["updatedAt", "createdAt"],
+  orderByDefault,
+  orderDefault = import_library_prisma2.Prisma.SortOrder.desc
+}) => z.object({
+  orderBy: z.enum(orderByEnum).default(orderByDefault || orderByEnum[0]),
+  order: z.nativeEnum(import_library_prisma2.Prisma.SortOrder).default(orderDefault),
   skip: z.any().transform((n) => parseInt(n, 10)).default(0),
   take: z.any().transform((n) => parseInt(n, 10)).default(10)
 });
@@ -11339,22 +11164,9 @@ var GetPackagesListResponse = ListView.extend({
     })
   ).array(),
   total: z.number(),
-  items: PackageModelResponse.merge(
-    z.object({
-      latest: PackageReleaseModelResponse,
-      latestVersion: z.string(),
-      latestRevisionId: z.string(),
-      label: z.string(),
-      releases: z.array(
-        z.object({
-          status: z.nativeEnum(import_library_prisma4.PackageStatusDetailsStatusEnum),
-          level: z.nativeEnum(import_library_prisma4.PackageStatusDetailsLevelEnum),
-          version: z.string(),
-          revisionId: z.string()
-        })
-      )
-    })
-  ).array()
+  items: PackageReleaseModelResponse.array().describe(
+    "Latest versions of every package id"
+  )
 });
 var GetPackageResponse = PackageModelResponse.merge(
   z.object({
@@ -11401,6 +11213,7 @@ var AddPackageReleaseReleaseStatusParams = UniversalPackageParams.merge(
   })
 );
 var GetPackagesParamsFilter = z.object({
+  prerelease: z.any().transform((o) => [void 0, true, "true", "1"].includes(o)).optional().default(false),
   schemaType: InAndNotInFunc({
     type: z.nativeEnum(import_library_prisma5.PackageSchemaTypeEnum)
   }).optional(),
@@ -11446,10 +11259,11 @@ var GetPackagesParamsFilter = z.object({
     })
   }).optional().default({})
 });
-var GetPackagesParams = PaginationParamsFunc([
-  "updatedAt",
-  "createdAt"
-]).merge(
+var GetPackagesParams = PaginationParamsFunc({
+  orderByEnum: ["label", "updatedAt", "createdAt", "versionInt"],
+  orderByDefault: "label",
+  orderDefault: "asc"
+}).merge(
   z.object({
     filter: GetPackagesParamsFilter.optional().default({}),
     scope: GetPackagesParamsFilter.pick({ id: true, categories: true }).optional().default({}),