@rexeus/typeweaver-types 0.0.2 → 0.0.4

package/dist/index.js

@@ -1,2109 +1,18 @@
-import { Path, BasePlugin } from '@rexeus/typeweaver-gen';
 import path from 'path';
-import { HttpStatusCode } from '@rexeus/typeweaver-core';
 import { fileURLToPath } from 'url';
-import { factory, SyntaxKind, createSourceFile, ScriptTarget, ScriptKind, createPrinter, EmitHint } from 'typescript';
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-var Case$2 = {exports: {}};
-
-var Case$1 = Case$2.exports;
-
-var hasRequiredCase;
-
-function requireCase () {
-	if (hasRequiredCase) return Case$2.exports;
-	hasRequiredCase = 1;
-	(function (module) {
-		/*! Case - v1.6.2 - 2020-03-24
-		* Copyright (c) 2020 Nathan Bubna; Licensed MIT, GPL */
-		(function() {
-		  var unicodes = function(s, prefix) {
-		    prefix = prefix || "";
-		    return s.replace(/(^|-)/g, "$1\\u" + prefix).replace(/,/g, "\\u" + prefix);
-		  }, basicSymbols = unicodes("20-26,28-2F,3A-40,5B-60,7B-7E,A0-BF,D7,F7", "00"), baseLowerCase = "a-z" + unicodes("DF-F6,F8-FF", "00"), baseUpperCase = "A-Z" + unicodes("C0-D6,D8-DE", "00"), improperInTitle = "A|An|And|As|At|But|By|En|For|If|In|Of|On|Or|The|To|Vs?\\.?|Via", regexps = function(symbols, lowers, uppers, impropers) {
-		    symbols = symbols || basicSymbols;
-		    lowers = lowers || baseLowerCase;
-		    uppers = uppers || baseUpperCase;
-		    impropers = impropers || improperInTitle;
-		    return {
-		      capitalize: new RegExp("(^|[" + symbols + "])([" + lowers + "])", "g"),
-		      pascal: new RegExp("(^|[" + symbols + "])+([" + lowers + uppers + "])", "g"),
-		      fill: new RegExp("[" + symbols + "]+(.|$)", "g"),
-		      sentence: new RegExp('(^\\s*|[\\?\\!\\.]+"?\\s+"?|,\\s+")([' + lowers + "])", "g"),
-		      improper: new RegExp("\\b(" + impropers + ")\\b", "g"),
-		      relax: new RegExp("([^" + uppers + "])([" + uppers + "]*)([" + uppers + "])(?=[^" + uppers + "]|$)", "g"),
-		      upper: new RegExp("^[^" + lowers + "]+$"),
-		      hole: /[^\s]\s[^\s]/,
-		      apostrophe: /'/g,
-		      room: new RegExp("[" + symbols + "]")
-		    };
-		  }, re = regexps(), _ = {
-		    re,
-		    unicodes,
-		    regexps,
-		    types: [],
-		    up: String.prototype.toUpperCase,
-		    low: String.prototype.toLowerCase,
-		    cap: function(s) {
-		      return _.up.call(s.charAt(0)) + s.slice(1);
-		    },
-		    decap: function(s) {
-		      return _.low.call(s.charAt(0)) + s.slice(1);
-		    },
-		    deapostrophe: function(s) {
-		      return s.replace(re.apostrophe, "");
-		    },
-		    fill: function(s, fill, deapostrophe) {
-		      if (fill != null) {
-		        s = s.replace(re.fill, function(m, next) {
-		          return next ? fill + next : "";
-		        });
-		      }
-		      if (deapostrophe) {
-		        s = _.deapostrophe(s);
-		      }
-		      return s;
-		    },
-		    prep: function(s, fill, pascal, upper) {
-		      s = s == null ? "" : s + "";
-		      if (!upper && re.upper.test(s)) {
-		        s = _.low.call(s);
-		      }
-		      if (!fill && !re.hole.test(s)) {
-		        var holey = _.fill(s, " ");
-		        if (re.hole.test(holey)) {
-		          s = holey;
-		        }
-		      }
-		      if (!pascal && !re.room.test(s)) {
-		        s = s.replace(re.relax, _.relax);
-		      }
-		      return s;
-		    },
-		    relax: function(m, before, acronym, caps) {
-		      return before + " " + (acronym ? acronym + " " : "") + caps;
-		    }
-		  }, Case = {
-		    _,
-		    of: function(s) {
-		      for (var i = 0, m = _.types.length; i < m; i++) {
-		        if (Case[_.types[i]].apply(Case, arguments) === s) {
-		          return _.types[i];
-		        }
-		      }
-		    },
-		    flip: function(s) {
-		      return s.replace(/\w/g, function(l) {
-		        return (l == _.up.call(l) ? _.low : _.up).call(l);
-		      });
-		    },
-		    random: function(s) {
-		      return s.replace(/\w/g, function(l) {
-		        return (Math.round(Math.random()) ? _.up : _.low).call(l);
-		      });
-		    },
-		    type: function(type2, fn) {
-		      Case[type2] = fn;
-		      _.types.push(type2);
-		    }
-		  }, types = {
-		    lower: function(s, fill, deapostrophe) {
-		      return _.fill(_.low.call(_.prep(s, fill)), fill, deapostrophe);
-		    },
-		    snake: function(s) {
-		      return Case.lower(s, "_", true);
-		    },
-		    constant: function(s) {
-		      return Case.upper(s, "_", true);
-		    },
-		    camel: function(s) {
-		      return _.decap(Case.pascal(s));
-		    },
-		    kebab: function(s) {
-		      return Case.lower(s, "-", true);
-		    },
-		    upper: function(s, fill, deapostrophe) {
-		      return _.fill(_.up.call(_.prep(s, fill, false, true)), fill, deapostrophe);
-		    },
-		    capital: function(s, fill, deapostrophe) {
-		      return _.fill(_.prep(s).replace(re.capitalize, function(m, border, letter) {
-		        return border + _.up.call(letter);
-		      }), fill, deapostrophe);
-		    },
-		    header: function(s) {
-		      return Case.capital(s, "-", true);
-		    },
-		    pascal: function(s) {
-		      return _.fill(_.prep(s, false, true).replace(re.pascal, function(m, border, letter) {
-		        return _.up.call(letter);
-		      }), "", true);
-		    },
-		    title: function(s) {
-		      return Case.capital(s).replace(re.improper, function(small, p, i, s2) {
-		        return i > 0 && i < s2.lastIndexOf(" ") ? _.low.call(small) : small;
-		      });
-		    },
-		    sentence: function(s, names, abbreviations) {
-		      s = Case.lower(s).replace(re.sentence, function(m, prelude, letter) {
-		        return prelude + _.up.call(letter);
-		      });
-		      if (names) {
-		        names.forEach(function(name) {
-		          s = s.replace(new RegExp("\\b" + Case.lower(name) + "\\b", "g"), _.cap);
-		        });
-		      }
-		      if (abbreviations) {
-		        abbreviations.forEach(function(abbr) {
-		          s = s.replace(new RegExp("(\\b" + Case.lower(abbr) + "\\. +)(\\w)"), function(m, abbrAndSpace, letter) {
-		            return abbrAndSpace + _.low.call(letter);
-		          });
-		        });
-		      }
-		      return s;
-		    }
-		  };
-		  types.squish = types.pascal;
-		  Case.default = Case;
-		  for (var type in types) {
-		    Case.type(type, types[type]);
-		  }
-		  var define = typeof define === "function" ? define : function() {
-		  };
-		  define(module.exports ? module.exports = Case : this.Case = Case);
-		}).call(Case$1); 
-	} (Case$2));
-	return Case$2.exports;
-}
-
-var CaseExports = requireCase();
-var Case = /*@__PURE__*/getDefaultExportFromCjs(CaseExports);
-
-// @__NO_SIDE_EFFECTS__
-function $constructor(name, initializer, params) {
-  function init(inst, def) {
-    var _a;
-    Object.defineProperty(inst, "_zod", {
-      value: inst._zod ?? {},
-      enumerable: false
-    });
-    (_a = inst._zod).traits ?? (_a.traits = /* @__PURE__ */ new Set());
-    inst._zod.traits.add(name);
-    initializer(inst, def);
-    for (const k in _.prototype) {
-      if (!(k in inst))
-        Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
-    }
-    inst._zod.constr = _;
-    inst._zod.def = def;
-  }
-  const Parent = params?.Parent ?? Object;
-  class Definition extends Parent {
-  }
-  Object.defineProperty(Definition, "name", { value: name });
-  function _(def) {
-    var _a;
-    const inst = params?.Parent ? new Definition() : this;
-    init(inst, def);
-    (_a = inst._zod).deferred ?? (_a.deferred = []);
-    for (const fn of inst._zod.deferred) {
-      fn();
-    }
-    return inst;
-  }
-  Object.defineProperty(_, "init", { value: init });
-  Object.defineProperty(_, Symbol.hasInstance, {
-    value: (inst) => {
-      if (params?.Parent && inst instanceof params.Parent)
-        return true;
-      return inst?._zod?.traits?.has(name);
-    }
-  });
-  Object.defineProperty(_, "name", { value: name });
-  return _;
-}
-class $ZodAsyncError extends Error {
-  constructor() {
-    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
-  }
-}
-const globalConfig = {};
-function config(newConfig) {
-  return globalConfig;
-}
-
-function getEnumValues(entries) {
-  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
-  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
-  return values;
-}
-function jsonStringifyReplacer(_, value) {
-  if (typeof value === "bigint")
-    return value.toString();
-  return value;
-}
-function cached(getter) {
-  return {
-    get value() {
-      {
-        const value = getter();
-        Object.defineProperty(this, "value", { value });
-        return value;
-      }
-    }
-  };
-}
-function cleanRegex(source) {
-  const start = source.startsWith("^") ? 1 : 0;
-  const end = source.endsWith("$") ? source.length - 1 : source.length;
-  return source.slice(start, end);
-}
-function defineLazy(object, key, getter) {
-  Object.defineProperty(object, key, {
-    get() {
-      {
-        const value = getter();
-        object[key] = value;
-        return value;
-      }
-    },
-    set(v) {
-      Object.defineProperty(object, key, {
-        value: v
-        // configurable: true,
-      });
-    },
-    configurable: true
-  });
-}
-function randomString(length = 10) {
-  const chars = "abcdefghijklmnopqrstuvwxyz";
-  let str = "";
-  for (let i = 0; i < length; i++) {
-    str += chars[Math.floor(Math.random() * chars.length)];
-  }
-  return str;
-}
-function esc(str) {
-  return JSON.stringify(str);
-}
-function isObject(data) {
-  return typeof data === "object" && data !== null && !Array.isArray(data);
-}
-const allowsEval = cached(() => {
-  if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
-    return false;
-  }
-  try {
-    const F = Function;
-    new F("");
-    return true;
-  } catch (_) {
-    return false;
-  }
-});
-function isPlainObject(o) {
-  if (isObject(o) === false)
-    return false;
-  const ctor = o.constructor;
-  if (ctor === void 0)
-    return true;
-  const prot = ctor.prototype;
-  if (isObject(prot) === false)
-    return false;
-  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
-    return false;
-  }
-  return true;
-}
-const propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
-const primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function optionalKeys(shape) {
-  return Object.keys(shape).filter((k) => {
-    return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
-  });
-}
-function aborted(x, startIndex = 0) {
-  for (let i = startIndex; i < x.issues.length; i++) {
-    if (x.issues[i].continue !== true)
-      return true;
-  }
-  return false;
-}
-function prefixIssues(path, issues) {
-  return issues.map((iss) => {
-    var _a;
-    (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path);
-    return iss;
-  });
-}
-function unwrapMessage(message) {
-  return typeof message === "string" ? message : message?.message;
-}
-function finalizeIssue(iss, ctx, config) {
-  const full = { ...iss, path: iss.path ?? [] };
-  if (!iss.message) {
-    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
-    full.message = message;
-  }
-  delete full.inst;
-  delete full.continue;
-  if (!ctx?.reportInput) {
-    delete full.input;
-  }
-  return full;
-}
-function issue(...args) {
-  const [iss, input, inst] = args;
-  if (typeof iss === "string") {
-    return {
-      message: iss,
-      code: "custom",
-      input,
-      inst
-    };
-  }
-  return { ...iss };
-}
-
-const initializer = (inst, def) => {
-  inst.name = "$ZodError";
-  Object.defineProperty(inst, "_zod", {
-    value: inst._zod,
-    enumerable: false
-  });
-  Object.defineProperty(inst, "issues", {
-    value: def,
-    enumerable: false
-  });
-  Object.defineProperty(inst, "message", {
-    get() {
-      return JSON.stringify(def, jsonStringifyReplacer, 2);
-    },
-    enumerable: true
-    // configurable: false,
-  });
-};
-const $ZodError = $constructor("$ZodError", initializer);
-const $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
-
-const _safeParse = (_Err) => (schema, value, _ctx) => {
-  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
-  if (result instanceof Promise) {
-    throw new $ZodAsyncError();
-  }
-  return result.issues.length ? {
-    success: false,
-    error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
-  } : { success: true, data: result.value };
-};
-const safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
-const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
-  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
-  let result = schema._zod.run({ value, issues: [] }, ctx);
-  if (result instanceof Promise)
-    result = await result;
-  return result.issues.length ? {
-    success: false,
-    error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
-  } : { success: true, data: result.value };
-};
-const safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
-
-const string = (params) => {
-  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
-  return new RegExp(`^${regex}$`);
-};
-const bigint = /^\d+n?$/;
-const number = /^-?\d+(?:\.\d+)?/i;
-const boolean = /true|false/i;
-const _null = /null/i;
-const _undefined = /undefined/i;
-
-const $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
-  var _a;
-  inst._zod ?? (inst._zod = {});
-  inst._zod.def = def;
-  (_a = inst._zod).onattach ?? (_a.onattach = []);
-});
-
-class Doc {
-  constructor(args = []) {
-    this.content = [];
-    this.indent = 0;
-    if (this)
-      this.args = args;
-  }
-  indented(fn) {
-    this.indent += 1;
-    fn(this);
-    this.indent -= 1;
-  }
-  write(arg) {
-    if (typeof arg === "function") {
-      arg(this, { execution: "sync" });
-      arg(this, { execution: "async" });
-      return;
-    }
-    const content = arg;
-    const lines = content.split("\n").filter((x) => x);
-    const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
-    const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
-    for (const line of dedented) {
-      this.content.push(line);
-    }
-  }
-  compile() {
-    const F = Function;
-    const args = this?.args;
-    const content = this?.content ?? [``];
-    const lines = [...content.map((x) => `  ${x}`)];
-    return new F(...args, lines.join("\n"));
-  }
-}
-
-const version = {
-  major: 4,
-  minor: 0,
-  patch: 0
-};
-
-const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
-  var _a;
-  inst ?? (inst = {});
-  defineLazy(inst._zod, "id", () => def.type + "_" + randomString(10));
-  inst._zod.def = def;
-  inst._zod.bag = inst._zod.bag || {};
-  inst._zod.version = version;
-  const checks2 = [...inst._zod.def.checks ?? []];
-  if (inst._zod.traits.has("$ZodCheck")) {
-    checks2.unshift(inst);
-  }
-  for (const ch of checks2) {
-    for (const fn of ch._zod.onattach) {
-      fn(inst);
-    }
-  }
-  if (checks2.length === 0) {
-    (_a = inst._zod).deferred ?? (_a.deferred = []);
-    inst._zod.deferred?.push(() => {
-      inst._zod.run = inst._zod.parse;
-    });
-  } else {
-    const runChecks = (payload, checks3, ctx) => {
-      let isAborted = aborted(payload);
-      let asyncResult;
-      for (const ch of checks3) {
-        if (ch._zod.when) {
-          const shouldRun = ch._zod.when(payload);
-          if (!shouldRun)
-            continue;
-        } else if (isAborted) {
-          continue;
-        }
-        const currLen = payload.issues.length;
-        const _ = ch._zod.check(payload);
-        if (_ instanceof Promise && ctx?.async === false) {
-          throw new $ZodAsyncError();
-        }
-        if (asyncResult || _ instanceof Promise) {
-          asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
-            await _;
-            const nextLen = payload.issues.length;
-            if (nextLen === currLen)
-              return;
-            if (!isAborted)
-              isAborted = aborted(payload, currLen);
-          });
-        } else {
-          const nextLen = payload.issues.length;
-          if (nextLen === currLen)
-            continue;
-          if (!isAborted)
-            isAborted = aborted(payload, currLen);
-        }
-      }
-      if (asyncResult) {
-        return asyncResult.then(() => {
-          return payload;
-        });
-      }
-      return payload;
-    };
-    inst._zod.run = (payload, ctx) => {
-      const result = inst._zod.parse(payload, ctx);
-      if (result instanceof Promise) {
-        if (ctx.async === false)
-          throw new $ZodAsyncError();
-        return result.then((result2) => runChecks(result2, checks2, ctx));
-      }
-      return runChecks(result, checks2, ctx);
-    };
-  }
-  inst["~standard"] = {
-    validate: (value) => {
-      try {
-        const r = safeParse(inst, value);
-        return r.success ? { value: r.data } : { issues: r.error?.issues };
-      } catch (_) {
-        return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
-      }
-    },
-    vendor: "zod",
-    version: 1
-  };
-});
-const $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
-  inst._zod.parse = (payload, _) => {
-    if (def.coerce)
-      try {
-        payload.value = String(payload.value);
-      } catch (_2) {
-      }
-    if (typeof payload.value === "string")
-      return payload;
-    payload.issues.push({
-      expected: "string",
-      code: "invalid_type",
-      input: payload.value,
-      inst
-    });
-    return payload;
-  };
-});
-const $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.pattern = inst._zod.bag.pattern ?? number;
-  inst._zod.parse = (payload, _ctx) => {
-    if (def.coerce)
-      try {
-        payload.value = Number(payload.value);
-      } catch (_) {
-      }
-    const input = payload.value;
-    if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
-      return payload;
-    }
-    const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
-    payload.issues.push({
-      expected: "number",
-      code: "invalid_type",
-      input,
-      inst,
-      ...received ? { received } : {}
-    });
-    return payload;
-  };
-});
-const $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.pattern = boolean;
-  inst._zod.parse = (payload, _ctx) => {
-    if (def.coerce)
-      try {
-        payload.value = Boolean(payload.value);
-      } catch (_) {
-      }
-    const input = payload.value;
-    if (typeof input === "boolean")
-      return payload;
-    payload.issues.push({
-      expected: "boolean",
-      code: "invalid_type",
-      input,
-      inst
-    });
-    return payload;
-  };
-});
-const $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.pattern = bigint;
-  inst._zod.parse = (payload, _ctx) => {
-    if (def.coerce)
-      try {
-        payload.value = BigInt(payload.value);
-      } catch (_) {
-      }
-    const { value: input } = payload;
-    if (typeof input === "bigint")
-      return payload;
-    payload.issues.push({
-      expected: "bigint",
-      code: "invalid_type",
-      input,
-      inst
-    });
-    return payload;
-  };
-});
-const $ZodSymbol = /* @__PURE__ */ $constructor("$ZodSymbol", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _ctx) => {
-    const { value: input } = payload;
-    if (typeof input === "symbol")
-      return payload;
-    payload.issues.push({
-      expected: "symbol",
-      code: "invalid_type",
-      input,
-      inst
-    });
-    return payload;
-  };
-});
-const $ZodUndefined = /* @__PURE__ */ $constructor("$ZodUndefined", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.pattern = _undefined;
-  inst._zod.values = /* @__PURE__ */ new Set([void 0]);
-  inst._zod.parse = (payload, _ctx) => {
-    const { value: input } = payload;
-    if (typeof input === "undefined")
-      return payload;
-    payload.issues.push({
-      expected: "undefined",
-      code: "invalid_type",
-      input,
-      inst
-    });
-    return payload;
-  };
-});
-const $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.pattern = _null;
-  inst._zod.values = /* @__PURE__ */ new Set([null]);
-  inst._zod.parse = (payload, _ctx) => {
-    const { value: input } = payload;
-    if (input === null)
-      return payload;
-    payload.issues.push({
-      expected: "null",
-      code: "invalid_type",
-      input,
-      inst
-    });
-    return payload;
-  };
-});
-const $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload) => payload;
-});
-const $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload) => payload;
-});
-const $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _ctx) => {
-    payload.issues.push({
-      expected: "never",
-      code: "invalid_type",
-      input: payload.value,
-      inst
-    });
-    return payload;
-  };
-});
-const $ZodVoid = /* @__PURE__ */ $constructor("$ZodVoid", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _ctx) => {
-    const { value: input } = payload;
-    if (typeof input === "undefined")
-      return payload;
-    payload.issues.push({
-      expected: "void",
-      code: "invalid_type",
-      input,
-      inst
-    });
-    return payload;
-  };
-});
-const $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _ctx) => {
-    if (def.coerce) {
-      try {
-        payload.value = new Date(payload.value);
-      } catch (_err) {
-      }
-    }
-    const input = payload.value;
-    const isDate = input instanceof Date;
-    const isValidDate = isDate && !Number.isNaN(input.getTime());
-    if (isValidDate)
-      return payload;
-    payload.issues.push({
-      expected: "date",
-      code: "invalid_type",
-      input,
-      ...isDate ? { received: "Invalid Date" } : {},
-      inst
-    });
-    return payload;
-  };
-});
-function handleArrayResult(result, final, index) {
-  if (result.issues.length) {
-    final.issues.push(...prefixIssues(index, result.issues));
-  }
-  final.value[index] = result.value;
-}
-const $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, ctx) => {
-    const input = payload.value;
-    if (!Array.isArray(input)) {
-      payload.issues.push({
-        expected: "array",
-        code: "invalid_type",
-        input,
-        inst
-      });
-      return payload;
-    }
-    payload.value = Array(input.length);
-    const proms = [];
-    for (let i = 0; i < input.length; i++) {
-      const item = input[i];
-      const result = def.element._zod.run({
-        value: item,
-        issues: []
-      }, ctx);
-      if (result instanceof Promise) {
-        proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
-      } else {
-        handleArrayResult(result, payload, i);
-      }
-    }
-    if (proms.length) {
-      return Promise.all(proms).then(() => payload);
-    }
-    return payload;
-  };
-});
-function handleObjectResult(result, final, key) {
-  if (result.issues.length) {
-    final.issues.push(...prefixIssues(key, result.issues));
-  }
-  final.value[key] = result.value;
-}
-function handleOptionalObjectResult(result, final, key, input) {
-  if (result.issues.length) {
-    if (input[key] === void 0) {
-      if (key in input) {
-        final.value[key] = void 0;
-      } else {
-        final.value[key] = result.value;
-      }
-    } else {
-      final.issues.push(...prefixIssues(key, result.issues));
-    }
-  } else if (result.value === void 0) {
-    if (key in input)
-      final.value[key] = void 0;
-  } else {
-    final.value[key] = result.value;
-  }
-}
-const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
-  $ZodType.init(inst, def);
-  const _normalized = cached(() => {
-    const keys = Object.keys(def.shape);
-    for (const k of keys) {
-      if (!(def.shape[k] instanceof $ZodType)) {
-        throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
-      }
-    }
-    const okeys = optionalKeys(def.shape);
-    return {
-      shape: def.shape,
-      keys,
-      keySet: new Set(keys),
-      numKeys: keys.length,
-      optionalKeys: new Set(okeys)
-    };
-  });
-  defineLazy(inst._zod, "propValues", () => {
-    const shape = def.shape;
-    const propValues = {};
-    for (const key in shape) {
-      const field = shape[key]._zod;
-      if (field.values) {
-        propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
-        for (const v of field.values)
-          propValues[key].add(v);
-      }
-    }
-    return propValues;
-  });
-  const generateFastpass = (shape) => {
-    const doc = new Doc(["shape", "payload", "ctx"]);
-    const { keys, optionalKeys } = _normalized.value;
-    const parseStr = (key) => {
-      const k = esc(key);
-      return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
-    };
-    doc.write(`const input = payload.value;`);
-    const ids = /* @__PURE__ */ Object.create(null);
-    for (const key of keys) {
-      ids[key] = randomString(15);
-    }
-    doc.write(`const newResult = {}`);
-    for (const key of keys) {
-      if (optionalKeys.has(key)) {
-        const id = ids[key];
-        doc.write(`const ${id} = ${parseStr(key)};`);
-        const k = esc(key);
-        doc.write(`
-        if (${id}.issues.length) {
-          if (input[${k}] === undefined) {
-            if (${k} in input) {
-              newResult[${k}] = undefined;
-            }
-          } else {
-            payload.issues = payload.issues.concat(
-              ${id}.issues.map((iss) => ({
-                ...iss,
-                path: iss.path ? [${k}, ...iss.path] : [${k}],
-              }))
-            );
-          }
-        } else if (${id}.value === undefined) {
-          if (${k} in input) newResult[${k}] = undefined;
-        } else {
-          newResult[${k}] = ${id}.value;
-        }
-        `);
-      } else {
-        const id = ids[key];
-        doc.write(`const ${id} = ${parseStr(key)};`);
-        doc.write(`
-          if (${id}.issues.length) payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
-            ...iss,
-            path: iss.path ? [${esc(key)}, ...iss.path] : [${esc(key)}]
-          })));`);
-        doc.write(`newResult[${esc(key)}] = ${id}.value`);
-      }
-    }
-    doc.write(`payload.value = newResult;`);
-    doc.write(`return payload;`);
-    const fn = doc.compile();
-    return (payload, ctx) => fn(shape, payload, ctx);
-  };
-  let fastpass;
-  const isObject$1 = isObject;
-  const jit = !globalConfig.jitless;
-  const allowsEval$1 = allowsEval;
-  const fastEnabled = jit && allowsEval$1.value;
-  const { catchall } = def;
-  let value;
-  inst._zod.parse = (payload, ctx) => {
-    value ?? (value = _normalized.value);
-    const input = payload.value;
-    if (!isObject$1(input)) {
-      payload.issues.push({
-        expected: "object",
-        code: "invalid_type",
-        input,
-        inst
-      });
-      return payload;
-    }
-    const proms = [];
-    if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
-      if (!fastpass)
-        fastpass = generateFastpass(def.shape);
-      payload = fastpass(payload, ctx);
-    } else {
-      payload.value = {};
-      const shape = value.shape;
-      for (const key of value.keys) {
-        const el = shape[key];
-        const r = el._zod.run({ value: input[key], issues: [] }, ctx);
-        const isOptional = el._zod.optin === "optional" && el._zod.optout === "optional";
-        if (r instanceof Promise) {
-          proms.push(r.then((r2) => isOptional ? handleOptionalObjectResult(r2, payload, key, input) : handleObjectResult(r2, payload, key)));
-        } else if (isOptional) {
-          handleOptionalObjectResult(r, payload, key, input);
-        } else {
-          handleObjectResult(r, payload, key);
-        }
-      }
-    }
-    if (!catchall) {
-      return proms.length ? Promise.all(proms).then(() => payload) : payload;
-    }
-    const unrecognized = [];
-    const keySet = value.keySet;
-    const _catchall = catchall._zod;
-    const t = _catchall.def.type;
-    for (const key of Object.keys(input)) {
-      if (keySet.has(key))
-        continue;
-      if (t === "never") {
-        unrecognized.push(key);
-        continue;
-      }
-      const r = _catchall.run({ value: input[key], issues: [] }, ctx);
-      if (r instanceof Promise) {
-        proms.push(r.then((r2) => handleObjectResult(r2, payload, key)));
-      } else {
-        handleObjectResult(r, payload, key);
-      }
-    }
-    if (unrecognized.length) {
-      payload.issues.push({
-        code: "unrecognized_keys",
-        keys: unrecognized,
-        input,
-        inst
-      });
-    }
-    if (!proms.length)
-      return payload;
-    return Promise.all(proms).then(() => {
-      return payload;
-    });
-  };
-});
-function handleUnionResults(results, final, inst, ctx) {
-  for (const result of results) {
-    if (result.issues.length === 0) {
-      final.value = result.value;
-      return final;
-    }
-  }
-  final.issues.push({
-    code: "invalid_union",
-    input: final.value,
-    inst,
-    errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
-  });
-  return final;
-}
-const $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
-  $ZodType.init(inst, def);
-  defineLazy(inst._zod, "values", () => {
-    if (def.options.every((o) => o._zod.values)) {
-      return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
-    }
-    return void 0;
-  });
-  defineLazy(inst._zod, "pattern", () => {
-    if (def.options.every((o) => o._zod.pattern)) {
-      const patterns = def.options.map((o) => o._zod.pattern);
-      return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
-    }
-    return void 0;
-  });
-  inst._zod.parse = (payload, ctx) => {
-    let async = false;
-    const results = [];
-    for (const option of def.options) {
-      const result = option._zod.run({
-        value: payload.value,
-        issues: []
-      }, ctx);
-      if (result instanceof Promise) {
-        results.push(result);
-        async = true;
-      } else {
-        if (result.issues.length === 0)
-          return result;
-        results.push(result);
-      }
-    }
-    if (!async)
-      return handleUnionResults(results, payload, inst, ctx);
-    return Promise.all(results).then((results2) => {
-      return handleUnionResults(results2, payload, inst, ctx);
-    });
-  };
-});
-const $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, ctx) => {
-    const { value: input } = payload;
-    const left = def.left._zod.run({ value: input, issues: [] }, ctx);
-    const right = def.right._zod.run({ value: input, issues: [] }, ctx);
-    const async = left instanceof Promise || right instanceof Promise;
-    if (async) {
-      return Promise.all([left, right]).then(([left2, right2]) => {
-        return handleIntersectionResults(payload, left2, right2);
-      });
-    }
-    return handleIntersectionResults(payload, left, right);
-  };
-});
-function mergeValues(a, b) {
-  if (a === b) {
-    return { valid: true, data: a };
-  }
-  if (a instanceof Date && b instanceof Date && +a === +b) {
-    return { valid: true, data: a };
-  }
-  if (isPlainObject(a) && isPlainObject(b)) {
-    const bKeys = Object.keys(b);
-    const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
-    const newObj = { ...a, ...b };
-    for (const key of sharedKeys) {
-      const sharedValue = mergeValues(a[key], b[key]);
-      if (!sharedValue.valid) {
-        return {
-          valid: false,
-          mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
-        };
-      }
-      newObj[key] = sharedValue.data;
-    }
-    return { valid: true, data: newObj };
-  }
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) {
-      return { valid: false, mergeErrorPath: [] };
-    }
-    const newArray = [];
-    for (let index = 0; index < a.length; index++) {
-      const itemA = a[index];
-      const itemB = b[index];
-      const sharedValue = mergeValues(itemA, itemB);
-      if (!sharedValue.valid) {
-        return {
-          valid: false,
-          mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
-        };
-      }
-      newArray.push(sharedValue.data);
-    }
-    return { valid: true, data: newArray };
-  }
-  return { valid: false, mergeErrorPath: [] };
-}
-function handleIntersectionResults(result, left, right) {
-  if (left.issues.length) {
-    result.issues.push(...left.issues);
-  }
-  if (right.issues.length) {
-    result.issues.push(...right.issues);
-  }
-  if (aborted(result))
-    return result;
-  const merged = mergeValues(left.value, right.value);
-  if (!merged.valid) {
-    throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
-  }
-  result.value = merged.data;
-  return result;
-}
-const $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
-  $ZodType.init(inst, def);
-  const items = def.items;
-  const optStart = items.length - [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
-  inst._zod.parse = (payload, ctx) => {
-    const input = payload.value;
-    if (!Array.isArray(input)) {
-      payload.issues.push({
-        input,
-        inst,
-        expected: "tuple",
-        code: "invalid_type"
-      });
-      return payload;
-    }
-    payload.value = [];
-    const proms = [];
-    if (!def.rest) {
-      const tooBig = input.length > items.length;
-      const tooSmall = input.length < optStart - 1;
-      if (tooBig || tooSmall) {
-        payload.issues.push({
-          input,
-          inst,
-          origin: "array",
-          ...tooBig ? { code: "too_big", maximum: items.length } : { code: "too_small", minimum: items.length }
-        });
-        return payload;
-      }
-    }
-    let i = -1;
-    for (const item of items) {
-      i++;
-      if (i >= input.length) {
-        if (i >= optStart)
-          continue;
-      }
-      const result = item._zod.run({
-        value: input[i],
-        issues: []
-      }, ctx);
-      if (result instanceof Promise) {
-        proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
-      } else {
-        handleTupleResult(result, payload, i);
-      }
-    }
-    if (def.rest) {
-      const rest = input.slice(items.length);
-      for (const el of rest) {
-        i++;
-        const result = def.rest._zod.run({
-          value: el,
-          issues: []
-        }, ctx);
-        if (result instanceof Promise) {
-          proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
-        } else {
-          handleTupleResult(result, payload, i);
-        }
-      }
-    }
-    if (proms.length)
-      return Promise.all(proms).then(() => payload);
-    return payload;
-  };
-});
-function handleTupleResult(result, final, index) {
-  if (result.issues.length) {
-    final.issues.push(...prefixIssues(index, result.issues));
-  }
-  final.value[index] = result.value;
-}
-const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, ctx) => {
-    const input = payload.value;
-    if (!isPlainObject(input)) {
-      payload.issues.push({
-        expected: "record",
-        code: "invalid_type",
-        input,
-        inst
-      });
-      return payload;
-    }
-    const proms = [];
-    if (def.keyType._zod.values) {
-      const values = def.keyType._zod.values;
-      payload.value = {};
-      for (const key of values) {
-        if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
-          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
-          if (result instanceof Promise) {
-            proms.push(result.then((result2) => {
-              if (result2.issues.length) {
-                payload.issues.push(...prefixIssues(key, result2.issues));
-              }
-              payload.value[key] = result2.value;
-            }));
-          } else {
-            if (result.issues.length) {
-              payload.issues.push(...prefixIssues(key, result.issues));
-            }
-            payload.value[key] = result.value;
-          }
-        }
-      }
-      let unrecognized;
-      for (const key in input) {
-        if (!values.has(key)) {
-          unrecognized = unrecognized ?? [];
-          unrecognized.push(key);
-        }
-      }
-      if (unrecognized && unrecognized.length > 0) {
-        payload.issues.push({
-          code: "unrecognized_keys",
-          input,
-          inst,
-          keys: unrecognized
-        });
-      }
-    } else {
-      payload.value = {};
-      for (const key of Reflect.ownKeys(input)) {
-        if (key === "__proto__")
-          continue;
-        const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
-        if (keyResult instanceof Promise) {
-          throw new Error("Async schemas not supported in object keys currently");
-        }
-        if (keyResult.issues.length) {
-          payload.issues.push({
-            origin: "record",
-            code: "invalid_key",
-            issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
-            input: key,
-            path: [key],
-            inst
-          });
-          payload.value[keyResult.value] = keyResult.value;
-          continue;
-        }
-        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
-        if (result instanceof Promise) {
-          proms.push(result.then((result2) => {
-            if (result2.issues.length) {
-              payload.issues.push(...prefixIssues(key, result2.issues));
-            }
-            payload.value[keyResult.value] = result2.value;
-          }));
-        } else {
-          if (result.issues.length) {
-            payload.issues.push(...prefixIssues(key, result.issues));
-          }
-          payload.value[keyResult.value] = result.value;
-        }
-      }
-    }
-    if (proms.length) {
-      return Promise.all(proms).then(() => payload);
-    }
-    return payload;
-  };
-});
-const $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, ctx) => {
-    const input = payload.value;
-    if (!(input instanceof Map)) {
-      payload.issues.push({
-        expected: "map",
-        code: "invalid_type",
-        input,
-        inst
-      });
-      return payload;
-    }
-    const proms = [];
-    payload.value = /* @__PURE__ */ new Map();
-    for (const [key, value] of input) {
-      const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
-      const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);
-      if (keyResult instanceof Promise || valueResult instanceof Promise) {
-        proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {
-          handleMapResult(keyResult2, valueResult2, payload, key, input, inst, ctx);
-        }));
-      } else {
-        handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);
-      }
-    }
-    if (proms.length)
-      return Promise.all(proms).then(() => payload);
-    return payload;
-  };
-});
-function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
-  if (keyResult.issues.length) {
-    if (propertyKeyTypes.has(typeof key)) {
-      final.issues.push(...prefixIssues(key, keyResult.issues));
-    } else {
-      final.issues.push({
-        origin: "map",
-        code: "invalid_key",
-        input,
-        inst,
-        issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
-      });
-    }
-  }
-  if (valueResult.issues.length) {
-    if (propertyKeyTypes.has(typeof key)) {
-      final.issues.push(...prefixIssues(key, valueResult.issues));
-    } else {
-      final.issues.push({
-        origin: "map",
-        code: "invalid_element",
-        input,
-        inst,
-        key,
-        issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
-      });
-    }
-  }
-  final.value.set(keyResult.value, valueResult.value);
-}
-const $ZodSet = /* @__PURE__ */ $constructor("$ZodSet", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, ctx) => {
-    const input = payload.value;
-    if (!(input instanceof Set)) {
-      payload.issues.push({
-        input,
-        inst,
-        expected: "set",
-        code: "invalid_type"
-      });
-      return payload;
-    }
-    const proms = [];
-    payload.value = /* @__PURE__ */ new Set();
-    for (const item of input) {
-      const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);
-      if (result instanceof Promise) {
-        proms.push(result.then((result2) => handleSetResult(result2, payload)));
-      } else
-        handleSetResult(result, payload);
-    }
-    if (proms.length)
-      return Promise.all(proms).then(() => payload);
-    return payload;
-  };
-});
-function handleSetResult(result, final) {
-  if (result.issues.length) {
-    final.issues.push(...result.issues);
-  }
-  final.value.add(result.value);
-}
-const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
-  $ZodType.init(inst, def);
-  const values = getEnumValues(def.entries);
-  inst._zod.values = new Set(values);
-  inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
-  inst._zod.parse = (payload, _ctx) => {
-    const input = payload.value;
-    if (inst._zod.values.has(input)) {
-      return payload;
-    }
-    payload.issues.push({
-      code: "invalid_value",
-      values,
-      input,
-      inst
-    });
-    return payload;
-  };
-});
-const $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.values = new Set(def.values);
-  inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? o.toString() : String(o)).join("|")})$`);
-  inst._zod.parse = (payload, _ctx) => {
-    const input = payload.value;
-    if (inst._zod.values.has(input)) {
-      return payload;
-    }
-    payload.issues.push({
-      code: "invalid_value",
-      values: def.values,
-      input,
-      inst
-    });
-    return payload;
-  };
-});
-const $ZodFile = /* @__PURE__ */ $constructor("$ZodFile", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _ctx) => {
-    const input = payload.value;
-    if (input instanceof File)
-      return payload;
-    payload.issues.push({
-      expected: "file",
-      code: "invalid_type",
-      input,
-      inst
-    });
-    return payload;
-  };
-});
-const $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _ctx) => {
-    const _out = def.transform(payload.value, payload);
-    if (_ctx.async) {
-      const output = _out instanceof Promise ? _out : Promise.resolve(_out);
-      return output.then((output2) => {
-        payload.value = output2;
-        return payload;
-      });
-    }
-    if (_out instanceof Promise) {
-      throw new $ZodAsyncError();
-    }
-    payload.value = _out;
-    return payload;
-  };
-});
-const $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.optin = "optional";
-  inst._zod.optout = "optional";
-  defineLazy(inst._zod, "values", () => {
-    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
-  });
-  defineLazy(inst._zod, "pattern", () => {
-    const pattern = def.innerType._zod.pattern;
-    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
-  });
-  inst._zod.parse = (payload, ctx) => {
-    if (payload.value === void 0) {
-      return payload;
-    }
-    return def.innerType._zod.run(payload, ctx);
-  };
-});
-const $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
-  $ZodType.init(inst, def);
-  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
-  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
-  defineLazy(inst._zod, "pattern", () => {
-    const pattern = def.innerType._zod.pattern;
-    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
-  });
-  defineLazy(inst._zod, "values", () => {
-    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;
-  });
-  inst._zod.parse = (payload, ctx) => {
-    if (payload.value === null)
-      return payload;
-    return def.innerType._zod.run(payload, ctx);
-  };
-});
-const $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.optin = "optional";
-  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
-  inst._zod.parse = (payload, ctx) => {
-    if (payload.value === void 0) {
-      payload.value = def.defaultValue;
-      return payload;
-    }
-    const result = def.innerType._zod.run(payload, ctx);
-    if (result instanceof Promise) {
-      return result.then((result2) => handleDefaultResult(result2, def));
-    }
-    return handleDefaultResult(result, def);
-  };
-});
-function handleDefaultResult(payload, def) {
-  if (payload.value === void 0) {
-    payload.value = def.defaultValue;
-  }
-  return payload;
-}
-const $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
-  $ZodType.init(inst, def);
-  defineLazy(inst._zod, "values", () => {
-    const v = def.innerType._zod.values;
-    return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
-  });
-  inst._zod.parse = (payload, ctx) => {
-    const result = def.innerType._zod.run(payload, ctx);
-    if (result instanceof Promise) {
-      return result.then((result2) => handleNonOptionalResult(result2, inst));
-    }
-    return handleNonOptionalResult(result, inst);
-  };
-});
-function handleNonOptionalResult(payload, inst) {
-  if (!payload.issues.length && payload.value === void 0) {
-    payload.issues.push({
-      code: "invalid_type",
-      expected: "nonoptional",
-      input: payload.value,
-      inst
-    });
-  }
-  return payload;
-}
-const $ZodSuccess = /* @__PURE__ */ $constructor("$ZodSuccess", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, ctx) => {
-    const result = def.innerType._zod.run(payload, ctx);
-    if (result instanceof Promise) {
-      return result.then((result2) => {
-        payload.value = result2.issues.length === 0;
-        return payload;
-      });
-    }
-    payload.value = result.issues.length === 0;
-    return payload;
-  };
-});
-const $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
-  $ZodType.init(inst, def);
-  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
-  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
-  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
-  inst._zod.parse = (payload, ctx) => {
-    const result = def.innerType._zod.run(payload, ctx);
-    if (result instanceof Promise) {
-      return result.then((result2) => {
-        payload.value = result2.value;
-        if (result2.issues.length) {
-          payload.value = def.catchValue({
-            ...payload,
-            error: {
-              issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
-            },
-            input: payload.value
-          });
-          payload.issues = [];
-        }
-        return payload;
-      });
-    }
-    payload.value = result.value;
-    if (result.issues.length) {
-      payload.value = def.catchValue({
-        ...payload,
-        error: {
-          issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
-        },
-        input: payload.value
-      });
-      payload.issues = [];
-    }
-    return payload;
-  };
-});
-const $ZodNaN = /* @__PURE__ */ $constructor("$ZodNaN", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _ctx) => {
-    if (typeof payload.value !== "number" || !Number.isNaN(payload.value)) {
-      payload.issues.push({
-        input: payload.value,
-        inst,
-        expected: "nan",
-        code: "invalid_type"
-      });
-      return payload;
-    }
-    return payload;
-  };
-});
-const $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
-  $ZodType.init(inst, def);
-  defineLazy(inst._zod, "values", () => def.in._zod.values);
-  defineLazy(inst._zod, "optin", () => def.in._zod.optin);
-  defineLazy(inst._zod, "optout", () => def.out._zod.optout);
-  inst._zod.parse = (payload, ctx) => {
-    const left = def.in._zod.run(payload, ctx);
-    if (left instanceof Promise) {
-      return left.then((left2) => handlePipeResult(left2, def, ctx));
-    }
-    return handlePipeResult(left, def, ctx);
-  };
-});
-function handlePipeResult(left, def, ctx) {
-  if (aborted(left)) {
-    return left;
-  }
-  return def.out._zod.run({ value: left.value, issues: left.issues }, ctx);
-}
-const $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
-  $ZodType.init(inst, def);
-  defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
-  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
-  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
-  inst._zod.parse = (payload, ctx) => {
-    const result = def.innerType._zod.run(payload, ctx);
-    if (result instanceof Promise) {
-      return result.then(handleReadonlyResult);
-    }
-    return handleReadonlyResult(result);
-  };
-});
-function handleReadonlyResult(payload) {
-  payload.value = Object.freeze(payload.value);
-  return payload;
-}
-const $ZodTemplateLiteral = /* @__PURE__ */ $constructor("$ZodTemplateLiteral", (inst, def) => {
-  $ZodType.init(inst, def);
-  const regexParts = [];
-  for (const part of def.parts) {
-    if (part instanceof $ZodType) {
-      if (!part._zod.pattern) {
-        throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`);
-      }
-      const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern;
-      if (!source)
-        throw new Error(`Invalid template literal part: ${part._zod.traits}`);
-      const start = source.startsWith("^") ? 1 : 0;
-      const end = source.endsWith("$") ? source.length - 1 : source.length;
-      regexParts.push(source.slice(start, end));
-    } else if (part === null || primitiveTypes.has(typeof part)) {
-      regexParts.push(escapeRegex(`${part}`));
-    } else {
-      throw new Error(`Invalid template literal part: ${part}`);
-    }
-  }
-  inst._zod.pattern = new RegExp(`^${regexParts.join("")}$`);
-  inst._zod.parse = (payload, _ctx) => {
-    if (typeof payload.value !== "string") {
-      payload.issues.push({
-        input: payload.value,
-        inst,
-        expected: "template_literal",
-        code: "invalid_type"
-      });
-      return payload;
-    }
-    inst._zod.pattern.lastIndex = 0;
-    if (!inst._zod.pattern.test(payload.value)) {
-      payload.issues.push({
-        input: payload.value,
-        inst,
-        code: "invalid_format",
-        format: "template_literal",
-        pattern: inst._zod.pattern.source
-      });
-      return payload;
-    }
-    return payload;
-  };
-});
-const $ZodPromise = /* @__PURE__ */ $constructor("$ZodPromise", (inst, def) => {
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, ctx) => {
-    return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx));
-  };
-});
-const $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
-  $ZodType.init(inst, def);
-  defineLazy(inst._zod, "innerType", () => def.getter());
-  defineLazy(inst._zod, "pattern", () => inst._zod.innerType._zod.pattern);
-  defineLazy(inst._zod, "propValues", () => inst._zod.innerType._zod.propValues);
-  defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin);
-  defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout);
-  inst._zod.parse = (payload, ctx) => {
-    const inner = inst._zod.innerType;
-    return inner._zod.run(payload, ctx);
-  };
-});
-const $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
-  $ZodCheck.init(inst, def);
-  $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _) => {
-    return payload;
-  };
-  inst._zod.check = (payload) => {
-    const input = payload.value;
-    const r = def.fn(input);
-    if (r instanceof Promise) {
-      return r.then((r2) => handleRefineResult(r2, payload, input, inst));
-    }
-    handleRefineResult(r, payload, input, inst);
-    return;
-  };
-});
-function handleRefineResult(result, payload, input, inst) {
-  if (!result) {
-    const _iss = {
-      code: "custom",
-      input,
-      inst,
-      // incorporates params.error into issue reporting
-      path: [...inst._zod.def.path ?? []],
-      // incorporates params.error into issue reporting
-      continue: !inst._zod.def.abort
-      // params: inst._zod.def.params,
-    };
-    if (inst._zod.def.params)
-      _iss.params = inst._zod.def.params;
-    payload.issues.push(issue(_iss));
-  }
-}
-
-class TsTypeNode {
-  static fromZod(zodType) {
-    if (zodType instanceof $ZodString) {
-      return TsTypeNode.fromZodString(zodType);
-    }
-    if (zodType instanceof $ZodNumber) {
-      return TsTypeNode.fromZodNumber(zodType);
-    }
-    if (zodType instanceof $ZodBigInt) {
-      return TsTypeNode.fromZodBigInt(zodType);
-    }
-    if (zodType instanceof $ZodBoolean) {
-      return TsTypeNode.fromZodBoolean(zodType);
-    }
-    if (zodType instanceof $ZodDate) {
-      return TsTypeNode.fromZodDate(zodType);
-    }
-    if (zodType instanceof $ZodSymbol) {
-      return TsTypeNode.fromZodSymbol(zodType);
-    }
-    if (zodType instanceof $ZodUndefined) {
-      return TsTypeNode.fromZodUndefined(zodType);
-    }
-    if (zodType instanceof $ZodNullable) {
-      return TsTypeNode.fromZodNullable(zodType);
-    }
-    if (zodType instanceof $ZodNull) {
-      return TsTypeNode.fromZodNull(zodType);
-    }
-    if (zodType instanceof $ZodAny) {
-      return TsTypeNode.fromZodAny(zodType);
-    }
-    if (zodType instanceof $ZodUnknown) {
-      return TsTypeNode.fromZodUnknown(zodType);
-    }
-    if (zodType instanceof $ZodNever) {
-      return TsTypeNode.fromZodNever(zodType);
-    }
-    if (zodType instanceof $ZodVoid) {
-      return TsTypeNode.fromZodVoid(zodType);
-    }
-    if (zodType instanceof $ZodArray) {
-      return TsTypeNode.fromZodArray(zodType);
-    }
-    if (zodType instanceof $ZodObject) {
-      return TsTypeNode.fromZodObject(zodType);
-    }
-    if (zodType instanceof $ZodUnion) {
-      return TsTypeNode.fromZodUnion(zodType);
-    }
-    if (zodType instanceof $ZodIntersection) {
-      return TsTypeNode.fromZodIntersection(zodType);
-    }
-    if (zodType instanceof $ZodTuple) {
-      return TsTypeNode.fromZodTuple(zodType);
-    }
-    if (zodType instanceof $ZodRecord) {
-      return TsTypeNode.fromZodRecord(zodType);
-    }
-    if (zodType instanceof $ZodMap) {
-      return TsTypeNode.fromZodMap(zodType);
-    }
-    if (zodType instanceof $ZodSet) {
-      return TsTypeNode.fromZodSet(zodType);
-    }
-    if (zodType instanceof $ZodLiteral) {
-      if (!TsTypeNode) {
-        throw new Error("ZodLiteral has no values");
-      }
-      return TsTypeNode.fromZodLiteral(zodType);
-    }
-    if (zodType instanceof $ZodEnum) {
-      return TsTypeNode.fromZodEnum(zodType);
-    }
-    if (zodType instanceof $ZodPromise) {
-      return TsTypeNode.fromZodPromise(zodType);
-    }
-    if (zodType instanceof $ZodLazy) {
-      return TsTypeNode.fromZodLazy(zodType);
-    }
-    if (zodType instanceof $ZodOptional) {
-      return TsTypeNode.fromZodOptional(zodType);
-    }
-    if (zodType instanceof $ZodDefault) {
-      return TsTypeNode.fromZodDefault(zodType);
-    }
-    if (zodType instanceof $ZodTemplateLiteral) {
-      return TsTypeNode.fromZodTemplateLiteral(zodType);
-    }
-    if (zodType instanceof $ZodCustom) {
-      return TsTypeNode.fromZodCustom(zodType);
-    }
-    if (zodType instanceof $ZodTransform) {
-      return TsTypeNode.fromZodTransform(zodType);
-    }
-    if (zodType instanceof $ZodNonOptional) {
-      return TsTypeNode.fromZodNonOptional(zodType);
-    }
-    if (zodType instanceof $ZodReadonly) {
-      return TsTypeNode.fromZodReadonly(zodType);
-    }
-    if (zodType instanceof $ZodNaN) {
-      return TsTypeNode.fromZodNaN(zodType);
-    }
-    if (zodType instanceof $ZodPipe) {
-      return TsTypeNode.fromZodPipe(zodType);
-    }
-    if (zodType instanceof $ZodSuccess) {
-      return TsTypeNode.fromZodSuccess(zodType);
-    }
-    if (zodType instanceof $ZodCatch) {
-      return TsTypeNode.fromZodCatch(zodType);
-    }
-    if (zodType instanceof $ZodFile) {
-      return TsTypeNode.fromZodFile(zodType);
-    }
-    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
-  }
-  static fromZodString(zodString) {
-    return factory.createKeywordTypeNode(SyntaxKind.StringKeyword);
-  }
-  static fromZodNumber(zodNumber) {
-    return factory.createKeywordTypeNode(SyntaxKind.NumberKeyword);
-  }
-  static fromZodBigInt(zodBigInt) {
-    return factory.createKeywordTypeNode(SyntaxKind.BigIntKeyword);
-  }
-  static fromZodBoolean(zodBoolean) {
-    return factory.createKeywordTypeNode(SyntaxKind.BooleanKeyword);
-  }
-  static fromZodDate(zodDate) {
-    return factory.createTypeReferenceNode(factory.createIdentifier("Date"));
-  }
-  static fromZodSymbol(zodSymbol) {
-    return factory.createKeywordTypeNode(SyntaxKind.SymbolKeyword);
-  }
-  static fromZodUndefined(zodUndefined) {
-    return factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword);
-  }
-  static fromZodNullable(zodNullable) {
-    const innerType = TsTypeNode.fromZod(zodNullable._zod.def.innerType);
-    return factory.createUnionTypeNode([
-      innerType,
-      factory.createLiteralTypeNode(factory.createNull())
-    ]);
-  }
-  static fromZodNull(zodNull) {
-    return factory.createLiteralTypeNode(factory.createNull());
-  }
-  static fromZodAny(zodAny) {
-    return factory.createKeywordTypeNode(SyntaxKind.AnyKeyword);
-  }
-  static fromZodUnknown(zodUnknown) {
-    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
-  }
-  static fromZodNever(zodNever) {
-    return factory.createKeywordTypeNode(SyntaxKind.NeverKeyword);
-  }
-  static fromZodVoid(zodVoid) {
-    return factory.createKeywordTypeNode(SyntaxKind.VoidKeyword);
-  }
-  static fromZodArray(zodArray) {
-    const innerType = TsTypeNode.fromZod(zodArray._zod.def.element);
-    return factory.createArrayTypeNode(innerType);
-  }
-  static fromZodObject(zodObject) {
-    const entries = Object.entries(zodObject._zod.def.shape);
-    const members = entries.map(([key, nextZodNode]) => {
-      const type = TsTypeNode.fromZod(nextZodNode);
-      if (!nextZodNode._zod?.def) {
-        console.warn(
-          `Zod node for key "${key}" does not have a _zod.def property. This may indicate an issue with the Zod schema.`,
-          {
-            key
-          }
-        );
-      }
-      const { type: nextZodNodeTypeName } = nextZodNode._zod?.def ?? {};
-      const isOptional = nextZodNodeTypeName === "optional";
-      const propertySignature = factory.createPropertySignature(
-        void 0,
-        TsTypeNode.createTsAstPropertyKey(key),
-        isOptional ? factory.createToken(SyntaxKind.QuestionToken) : void 0,
-        type
-      );
-      return propertySignature;
-    });
-    return factory.createTypeLiteralNode(members);
-  }
-  static fromZodUnion(zodUnion) {
-    const options = zodUnion._zod.def.options.map(TsTypeNode.fromZod);
-    return factory.createUnionTypeNode(options);
-  }
-  static fromZodIntersection(zodIntersection) {
-    const left = TsTypeNode.fromZod(zodIntersection._zod.def.left);
-    const right = TsTypeNode.fromZod(zodIntersection._zod.def.right);
-    return factory.createIntersectionTypeNode([left, right]);
-  }
-  static fromZodTuple(zodTuple) {
-    const elements = zodTuple._zod.def.items.map(TsTypeNode.fromZod);
-    return factory.createTupleTypeNode(elements);
-  }
-  static fromZodRecord(zodRecord) {
-    const keyType = TsTypeNode.fromZod(zodRecord._zod.def.keyType);
-    const valueType = TsTypeNode.fromZod(zodRecord._zod.def.valueType);
-    return factory.createTypeReferenceNode(factory.createIdentifier("Record"), [
-      keyType,
-      valueType
-    ]);
-  }
-  static fromZodMap(zodMap) {
-    const keyType = TsTypeNode.fromZod(zodMap._zod.def.keyType);
-    const valueType = TsTypeNode.fromZod(zodMap._zod.def.valueType);
-    return factory.createTypeReferenceNode(factory.createIdentifier("Map"), [
-      keyType,
-      valueType
-    ]);
-  }
-  static fromZodSet(zodSet) {
-    const innerType = TsTypeNode.fromZod(zodSet._zod.def.valueType);
-    return factory.createTypeReferenceNode(factory.createIdentifier("Set"), [
-      innerType
-    ]);
-  }
-  static fromZodLiteral(zodLiteral) {
-    if (zodLiteral._zod.def.values.length === 0) {
-      throw new Error("ZodLiteral has no values");
-    }
-    const value = zodLiteral._zod.def.values[0];
-    if (typeof value === "string") {
-      return factory.createLiteralTypeNode(factory.createStringLiteral(value));
-    }
-    if (typeof value === "number") {
-      return factory.createLiteralTypeNode(factory.createNumericLiteral(value));
-    }
-    if (typeof value === "boolean") {
-      return factory.createLiteralTypeNode(
-        value ? factory.createTrue() : factory.createFalse()
-      );
-    }
-    if (typeof value === "bigint") {
-      return factory.createLiteralTypeNode(
-        factory.createBigIntLiteral(value.toString())
-      );
-    }
-    if (value === null) {
-      return factory.createLiteralTypeNode(factory.createNull());
-    }
-    if (value === void 0) {
-      return factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword);
-    }
-    throw new Error(`Unsupported literal type: ${typeof value}`);
-  }
-  static fromZodEnum(zodEnum) {
-    const entries = Object.entries(zodEnum._zod.def.entries);
-    const types = entries.map(([key, value]) => {
-      return factory.createLiteralTypeNode(factory.createStringLiteral(key));
-    });
-    return factory.createUnionTypeNode(types);
-  }
-  static fromZodPromise(zodPromise) {
-    const innerType = TsTypeNode.fromZod(zodPromise._zod.def.innerType);
-    return factory.createTypeReferenceNode(
-      factory.createIdentifier("Promise"),
-      [innerType]
-    );
-  }
-  static fromZodLazy(zodLazy) {
-    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
-  }
-  static fromZodOptional(zodOptional) {
-    const innerType = TsTypeNode.fromZod(zodOptional._zod.def.innerType);
-    return factory.createUnionTypeNode([
-      innerType,
-      factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword)
-    ]);
-  }
-  static fromZodDefault(zodDefault) {
-    const innerType = TsTypeNode.fromZod(zodDefault._zod.def.innerType);
-    const filteredNodes = [];
-    innerType.forEachChild((node) => {
-      if (node.kind !== SyntaxKind.UndefinedKeyword) {
-        filteredNodes.push(node);
-      }
-    });
-    innerType.types = filteredNodes;
-    return innerType;
-  }
-  static fromZodTemplateLiteral(zodTemplateLiteral) {
-    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
-  }
-  static fromZodCustom(zodCustom) {
-    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
-  }
-  static fromZodTransform(zodTransform) {
-    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
-  }
-  static fromZodNonOptional(zodNonOptional) {
-    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
-  }
-  static fromZodReadonly(zodReadonly) {
-    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
-  }
-  static fromZodNaN(zodNaN) {
-    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
-  }
-  static fromZodPipe(zodPipe) {
-    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
-  }
-  static fromZodSuccess(zodSuccess) {
-    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
-  }
-  static fromZodCatch(zodCatch) {
-    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
-  }
-  static fromZodFile(zodFile) {
-    return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
-  }
-  /**
-   * Returns a TypeScript AST node representing the property key.
-   * If the key is a valid JavaScript identifier, returns an Identifier node.
-   * Otherwise, returns a StringLiteral node.
-   *
-   * @param {string} key - The property key to convert.
-   * @returns {Identifier | StringLiteral} The corresponding AST node for the property key.
-   */
-  static createTsAstPropertyKey(key) {
-    if (/^[$A-Z_a-z][\w$]*$/.test(key)) {
-      return factory.createIdentifier(key);
-    }
-    return factory.createStringLiteral(key);
-  }
-}
-
-class TsTypePrinter {
-  static print(tsType) {
-    const sourceFile = createSourceFile(
-      "print.ts",
-      "",
-      ScriptTarget.Latest,
-      false,
-      ScriptKind.TS
-    );
-    const printer = createPrinter();
-    return printer.printNode(EmitHint.Unspecified, tsType, sourceFile);
-  }
-}
+import { Path, BasePlugin } from '@rexeus/typeweaver-gen';
+import { TsTypePrinter, TsTypeNode } from '@rexeus/typeweaver-zod-to-ts';
+import Case from 'case';
+import { HttpStatusCode } from '@rexeus/typeweaver-core';
 
 const __dirname$5 = path.dirname(fileURLToPath(import.meta.url));
-class SharedResponseGenerator {
-  static generate(context) {
-    const templateFile = path.join(
-      __dirname$5,
-      "templates",
-      "SharedResponse.ejs"
-    );
-    for (const sharedResponse of context.resources.sharedResponseResources) {
-      this.writeSharedResponse(templateFile, sharedResponse, context);
-    }
-  }
-  static writeSharedResponse(templateFile, sharedResponse, context) {
-    const headerTsType = sharedResponse.header ? TsTypePrinter.print(TsTypeNode.fromZod(sharedResponse.header)) : void 0;
-    const bodyTsType = sharedResponse.body ? TsTypePrinter.print(TsTypeNode.fromZod(sharedResponse.body)) : void 0;
-    const pascalCaseName = Case.pascal(sharedResponse.name);
-    const content = context.renderTemplate(templateFile, {
-      coreDir: context.coreDir,
-      httpStatusCode: HttpStatusCode,
-      headerTsType,
-      bodyTsType,
-      pascalCaseName,
-      sharedResponse
-    });
-    const relativePath = path.relative(context.outputDir, sharedResponse.outputFile);
-    context.writeFile(relativePath, content);
-  }
-}
-
-const __dirname$4 = path.dirname(fileURLToPath(import.meta.url));
 class RequestGenerator {
   static generate(context) {
-    const templateFilePath = path.join(__dirname$4, "templates", "Request.ejs");
-    for (const [, operationResources] of Object.entries(
+    const templateFilePath = path.join(__dirname$5, "templates", "Request.ejs");
+    for (const [, entityResource] of Object.entries(
       context.resources.entityResources
     )) {
-      for (const definition of operationResources) {
+      for (const definition of entityResource.operations) {
         this.writeRequestType(templateFilePath, definition, context);
       }
     }
@@ -2124,31 +33,41 @@ class RequestGenerator {
     const pascalCaseOperationId = Case.pascal(operationId);
     const sourcePath = Path.relative(
       outputDir,
-      `${operationResource.sourceDir}/${path.basename(operationResource.sourceFile, ".ts")}`
+      `${operationResource.sourceDir}/${path.relative(operationResource.sourceDir, operationResource.sourceFile).replace(/\.ts$/, "")}`
     );
     const ownSuccessResponses = [];
     const ownErrorResponses = [];
     const sharedSuccessResponses = [];
     const sharedErrorResponses = [];
     for (const response of responses) {
-      const { statusCode, name, isShared } = response;
-      if (isShared) {
+      const { statusCode, name, isReference } = response;
+      if (isReference) {
         const sharedResponse = context.resources.sharedResponseResources.find(
-          (resource) => {
-            return resource.name === name;
-          }
+          (resource) => resource.name === name
         );
+        let responsePath;
         if (!sharedResponse) {
-          throw new Error(
-            `Shared response '${response.name}' not found in shared resources`
+          const entityResponses = context.resources.entityResources[operationResource.entityName]?.responses;
+          const entityResponse = entityResponses?.find((r) => r.name === name);
+          if (entityResponse) {
+            responsePath = Path.relative(
+              outputDir,
+              `${entityResponse.outputDir}/${path.basename(entityResponse.outputFileName, ".ts")}`
+            );
+          } else {
+            throw new Error(
+              `Shared response '${response.name}' not found in shared or entity resources`
+            );
+          }
+        } else {
+          responsePath = Path.relative(
+            outputDir,
+            `${sharedResponse.outputDir}/${path.basename(sharedResponse.outputFileName, ".ts")}`
           );
         }
         const assembledResponse2 = {
           name,
-          path: Path.relative(
-            outputDir,
-            `${sharedResponse.outputDir}/${path.basename(sharedResponse.outputFileName, ".ts")}`
-          )
+          path: responsePath
         };
         if (statusCode >= 200 && statusCode < 300) {
           sharedSuccessResponses.push(assembledResponse2);
@@ -2191,23 +110,26 @@ class RequestGenerator {
       hasErrorResponses: ownErrorResponses.length > 0 || sharedErrorResponses.length > 0,
       hasSuccessResponses: ownSuccessResponses.length > 0 || sharedSuccessResponses.length > 0
     });
-    const relativePath = path.relative(context.outputDir, operationResource.outputRequestFile);
+    const relativePath = path.relative(
+      context.outputDir,
+      operationResource.outputRequestFile
+    );
     context.writeFile(relativePath, content);
   }
 }
 
-const __dirname$3 = path.dirname(fileURLToPath(import.meta.url));
+const __dirname$4 = path.dirname(fileURLToPath(import.meta.url));
 class RequestValidationGenerator {
   static generate(context) {
     const templateFilePath = path.join(
-      __dirname$3,
+      __dirname$4,
       "templates",
       "RequestValidator.ejs"
     );
-    for (const [, operationResources] of Object.entries(
+    for (const [, entityResource] of Object.entries(
       context.resources.entityResources
     )) {
-      for (const definition of operationResources) {
+      for (const definition of entityResource.operations) {
         this.writeRequestValidator(templateFilePath, definition, context);
       }
     }
@@ -2222,7 +144,7 @@ class RequestValidationGenerator {
       operationId,
       sourcePath: Path.relative(
         outputDir,
-        `${operationResource.sourceDir}/${path.basename(operationResource.sourceFile, ".ts")}`
+        `${operationResource.sourceDir}/${path.relative(operationResource.sourceDir, operationResource.sourceFile).replace(/\.ts$/, "")}`
       ),
       corePath: context.coreDir,
       requestFile: Path.relative(
@@ -2234,21 +156,36 @@ class RequestValidationGenerator {
       param,
       header
     });
-    const relativePath = path.relative(context.outputDir, operationResource.outputRequestValidationFile);
+    const relativePath = path.relative(
+      context.outputDir,
+      operationResource.outputRequestValidationFile
+    );
     context.writeFile(relativePath, content);
   }
 }
 
-const __dirname$2 = path.dirname(fileURLToPath(import.meta.url));
+const __dirname$3 = path.dirname(fileURLToPath(import.meta.url));
 class ResponseGenerator {
   static generate(context) {
-    const templateFile = path.join(__dirname$2, "templates", "Response.ejs");
-    for (const [, operationResources] of Object.entries(
+    const templateFile = path.join(__dirname$3, "templates", "Response.ejs");
+    const sharedResponseTemplateFile = path.join(
+      __dirname$3,
+      "templates",
+      "SharedResponse.ejs"
+    );
+    for (const [, entityResource] of Object.entries(
       context.resources.entityResources
     )) {
-      for (const definition of operationResources) {
+      for (const definition of entityResource.operations) {
         this.writeResponseType(templateFile, definition, context);
       }
+      for (const responseResource of entityResource.responses) {
+        this.writeEntityResponseType(
+          sharedResponseTemplateFile,
+          responseResource,
+          context
+        );
+      }
     }
   }
   static writeResponseType(templateFile, resource, context) {
@@ -2265,25 +202,35 @@ class ResponseGenerator {
     const ownResponses = [];
     const sharedResponses = [];
     for (const response of responses) {
-      const { statusCode, name, isShared, body, header } = response;
-      if (isShared) {
+      const { statusCode, name, body, header, isReference } = response;
+      if (isReference) {
         const sharedResponse = context.resources.sharedResponseResources.find(
-          (resource2) => {
-            return resource2.name === name;
-          }
+          (resource2) => resource2.name === name
         );
-        if (!sharedResponse) {
-          throw new Error(
-            `Shared response '${response.name}' not found in shared resources`
-          );
+        if (sharedResponse) {
+          sharedResponses.push({
+            name,
+            path: Path.relative(
+              outputDir,
+              `${sharedResponse.outputDir}/${path.basename(sharedResponse.outputFileName, ".ts")}`
+            )
+          });
+        } else {
+          const entityResponses = context.resources.entityResources[resource.entityName]?.responses;
+          const entityResponse = entityResponses?.find((r) => r.name === name);
+          if (!entityResponse) {
+            throw new Error(
+              `Response ${name} not found in shared or entity-specific responses`
+            );
+          }
+          sharedResponses.push({
+            name,
+            path: Path.relative(
+              outputDir,
+              `${entityResponse.outputDir}/${path.basename(entityResponse.outputFileName, ".ts")}`
+            )
+          });
         }
-        sharedResponses.push({
-          name,
-          path: Path.relative(
-            outputDir,
-            `${sharedResponse.outputDir}/${path.basename(sharedResponse.outputFileName, ".ts")}`
-          )
-        });
         continue;
       }
       ownResponses.push({
@@ -2306,27 +253,48 @@ class ResponseGenerator {
       ),
       sourcePath: Path.relative(
         outputDir,
-        `${sourceDir}/${path.basename(sourceFile, ".ts")}`
+        `${sourceDir}/${path.relative(sourceDir, sourceFile).replace(/\.ts$/, "")}`
       )
     });
     const relativePath = path.relative(context.outputDir, outputResponseFile);
     context.writeFile(relativePath, content);
   }
+  static writeEntityResponseType(templateFile, resource, context) {
+    const { name, body, header, outputFile } = resource;
+    const pascalCaseName = Case.pascal(name);
+    const headerTsType = header ? TsTypePrinter.print(TsTypeNode.fromZod(header)) : void 0;
+    const bodyTsType = body ? TsTypePrinter.print(TsTypeNode.fromZod(body)) : void 0;
+    const content = context.renderTemplate(templateFile, {
+      coreDir: context.coreDir,
+      httpStatusCode: HttpStatusCode,
+      headerTsType,
+      bodyTsType,
+      pascalCaseName,
+      sharedResponse: resource
+      // The template expects this property name
+    });
+    const relativePath = path.relative(context.outputDir, outputFile);
+    context.writeFile(relativePath, content);
+  }
 }
 
-const __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
+const __dirname$2 = path.dirname(fileURLToPath(import.meta.url));
 class ResponseValidationGenerator {
   static generate(context) {
     const templateFilePath = path.join(
-      __dirname$1,
+      __dirname$2,
       "templates",
       "ResponseValidator.ejs"
     );
-    for (const [, operationResources] of Object.entries(
+    for (const [, entityResource] of Object.entries(
       context.resources.entityResources
     )) {
-      for (const operationResource of operationResources) {
-        this.writeResponseValidator(templateFilePath, operationResource, context);
+      for (const operationResource of entityResource.operations) {
+        this.writeResponseValidator(
+          templateFilePath,
+          operationResource,
+          context
+        );
       }
     }
   }
@@ -2345,7 +313,7 @@ class ResponseValidationGenerator {
     const sharedResponses = [];
     const allStatusCodes = [];
     for (const response of responses) {
-      const { statusCode, name, isShared, body, header, statusCodeName } = response;
+      const { statusCode, name, isReference, body, header, statusCodeName } = response;
       const index = responses.indexOf(response);
       const isStatusCodeIncluded = allStatusCodes.some((status) => {
         return status.statusCode === statusCode;
@@ -2356,23 +324,33 @@ class ResponseValidationGenerator {
           name: statusCodeName
         });
       }
-      if (isShared) {
+      if (isReference) {
         const sharedResponse = context.resources.sharedResponseResources.find(
-          (resource2) => {
-            return resource2.name === name;
-          }
+          (resource2) => resource2.name === name
         );
+        let importPath;
         if (!sharedResponse) {
-          throw new Error(
-            `Shared response '${response.name}' not found in shared resources`
+          const entityResponses = context.resources.entityResources[resource.entityName]?.responses;
+          const entityResponse = entityResponses?.find((r) => r.name === name);
+          if (entityResponse) {
+            importPath = Path.relative(
+              outputDir,
+              `${entityResponse.outputDir}/${path.basename(entityResponse.outputFileName, ".ts")}`
+            );
+          } else {
+            throw new Error(
+              `Shared response '${response.name}' not found in shared or entity resources`
+            );
+          }
+        } else {
+          importPath = Path.relative(
+            outputDir,
+            `${sharedResponse.outputDir}/${path.basename(sharedResponse.outputFileName, ".ts")}`
           );
         }
         sharedResponses.push({
           name,
-          importPath: Path.relative(
-            outputDir,
-            `${sharedResponse.outputDir}/${path.basename(sharedResponse.outputFileName, ".ts")}`
-          ),
+          importPath,
           hasBody: !!body,
           hasHeader: !!header,
           statusCode,
@@ -2396,13 +374,48 @@ class ResponseValidationGenerator {
       responseFile: `./${path.basename(outputResponseFileName, ".ts")}`,
       sourcePath: Path.relative(
         outputDir,
-        `${sourceDir}/${path.basename(sourceFile, ".ts")}`
+        `${sourceDir}/${path.relative(sourceDir, sourceFile).replace(/\.ts$/, "")}`
       ),
       sharedResponses,
       ownResponses,
       allStatusCodes
     });
-    const relativePath = path.relative(context.outputDir, outputResponseValidationFile);
+    const relativePath = path.relative(
+      context.outputDir,
+      outputResponseValidationFile
+    );
+    context.writeFile(relativePath, content);
+  }
+}
+
+const __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
+class SharedResponseGenerator {
+  static generate(context) {
+    const templateFile = path.join(
+      __dirname$1,
+      "templates",
+      "SharedResponse.ejs"
+    );
+    for (const sharedResponse of context.resources.sharedResponseResources) {
+      this.writeSharedResponse(templateFile, sharedResponse, context);
+    }
+  }
+  static writeSharedResponse(templateFile, sharedResponse, context) {
+    const headerTsType = sharedResponse.header ? TsTypePrinter.print(TsTypeNode.fromZod(sharedResponse.header)) : void 0;
+    const bodyTsType = sharedResponse.body ? TsTypePrinter.print(TsTypeNode.fromZod(sharedResponse.body)) : void 0;
+    const pascalCaseName = Case.pascal(sharedResponse.name);
+    const content = context.renderTemplate(templateFile, {
+      coreDir: context.coreDir,
+      httpStatusCode: HttpStatusCode,
+      headerTsType,
+      bodyTsType,
+      pascalCaseName,
+      sharedResponse
+    });
+    const relativePath = path.relative(
+      context.outputDir,
+      sharedResponse.outputFile
+    );
     context.writeFile(relativePath, content);
   }
 }