@rexeus/typeweaver-types 0.0.1

package/dist/index.js

@@ -0,0 +1,2424 @@
+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);
+  }
+}
+
+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(
+      context.resources.entityResources
+    )) {
+      for (const definition of operationResources) {
+        this.writeRequestType(templateFilePath, definition, context);
+      }
+    }
+  }
+  static writeRequestType(templateFilePath, operationResource, context) {
+    const {
+      outputDir,
+      definition,
+      outputResponseFileName,
+      outputResponseValidationFileName
+    } = operationResource;
+    const { request, operationId, method, responses } = definition;
+    const { header, query, param, body } = request;
+    const headerTsType = header ? TsTypePrinter.print(TsTypeNode.fromZod(header)) : void 0;
+    const queryTsType = query ? TsTypePrinter.print(TsTypeNode.fromZod(query)) : void 0;
+    const paramTsType = param ? TsTypePrinter.print(TsTypeNode.fromZod(param)) : void 0;
+    const bodyTsType = body ? TsTypePrinter.print(TsTypeNode.fromZod(body)) : void 0;
+    const pascalCaseOperationId = Case.pascal(operationId);
+    const sourcePath = Path.relative(
+      outputDir,
+      `${operationResource.sourceDir}/${path.basename(operationResource.sourceFile, ".ts")}`
+    );
+    const ownSuccessResponses = [];
+    const ownErrorResponses = [];
+    const sharedSuccessResponses = [];
+    const sharedErrorResponses = [];
+    for (const response of responses) {
+      const { statusCode, name, isShared } = response;
+      if (isShared) {
+        const sharedResponse = context.resources.sharedResponseResources.find(
+          (resource) => {
+            return resource.name === name;
+          }
+        );
+        if (!sharedResponse) {
+          throw new Error(
+            `Shared response '${response.name}' not found in shared resources`
+          );
+        }
+        const assembledResponse2 = {
+          name,
+          path: Path.relative(
+            outputDir,
+            `${sharedResponse.outputDir}/${path.basename(sharedResponse.outputFileName, ".ts")}`
+          )
+        };
+        if (statusCode >= 200 && statusCode < 300) {
+          sharedSuccessResponses.push(assembledResponse2);
+        } else {
+          sharedErrorResponses.push(assembledResponse2);
+        }
+        continue;
+      }
+      const assembledResponse = {
+        name
+      };
+      if (statusCode >= 200 && statusCode < 300) {
+        ownSuccessResponses.push(assembledResponse);
+      } else {
+        ownErrorResponses.push(assembledResponse);
+      }
+    }
+    const content = context.renderTemplate(templateFilePath, {
+      pascalCaseOperationId,
+      operationId,
+      coreDir: context.coreDir,
+      sourcePath,
+      headerTsType,
+      queryTsType,
+      paramTsType,
+      bodyTsType,
+      method,
+      ownSuccessResponses,
+      ownErrorResponses,
+      sharedSuccessResponses,
+      sharedErrorResponses,
+      responseFile: Path.relative(
+        outputDir,
+        `${outputDir}/${path.basename(outputResponseFileName, ".ts")}`
+      ),
+      responseValidationFile: Path.relative(
+        outputDir,
+        `${outputDir}/${path.basename(outputResponseValidationFileName, ".ts")}`
+      ),
+      hasErrorResponses: ownErrorResponses.length > 0 || sharedErrorResponses.length > 0,
+      hasSuccessResponses: ownSuccessResponses.length > 0 || sharedSuccessResponses.length > 0
+    });
+    const relativePath = path.relative(context.outputDir, operationResource.outputRequestFile);
+    context.writeFile(relativePath, content);
+  }
+}
+
+const __dirname$3 = path.dirname(fileURLToPath(import.meta.url));
+class RequestValidationGenerator {
+  static generate(context) {
+    const templateFilePath = path.join(
+      __dirname$3,
+      "templates",
+      "RequestValidator.ejs"
+    );
+    for (const [, operationResources] of Object.entries(
+      context.resources.entityResources
+    )) {
+      for (const definition of operationResources) {
+        this.writeRequestValidator(templateFilePath, definition, context);
+      }
+    }
+  }
+  static writeRequestValidator(templateFilePath, operationResource, context) {
+    const { outputDir, definition, outputRequestFileName } = operationResource;
+    const { operationId, request } = definition;
+    const { body, query, param, header } = request;
+    const pascalCaseOperationId = Case.pascal(operationId);
+    const content = context.renderTemplate(templateFilePath, {
+      pascalCaseOperationId,
+      operationId,
+      sourcePath: Path.relative(
+        outputDir,
+        `${operationResource.sourceDir}/${path.basename(operationResource.sourceFile, ".ts")}`
+      ),
+      corePath: context.coreDir,
+      requestFile: Path.relative(
+        outputDir,
+        `${outputDir}/${path.basename(outputRequestFileName, ".ts")}`
+      ),
+      body,
+      query,
+      param,
+      header
+    });
+    const relativePath = path.relative(context.outputDir, operationResource.outputRequestValidationFile);
+    context.writeFile(relativePath, content);
+  }
+}
+
+const __dirname$2 = 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(
+      context.resources.entityResources
+    )) {
+      for (const definition of operationResources) {
+        this.writeResponseType(templateFile, definition, context);
+      }
+    }
+  }
+  static writeResponseType(templateFile, resource, context) {
+    const {
+      definition,
+      outputResponseFile,
+      outputDir,
+      outputResponseFileName,
+      sourceDir,
+      sourceFile
+    } = resource;
+    const { responses, operationId } = definition;
+    const pascalCaseOperationId = Case.pascal(operationId);
+    const ownResponses = [];
+    const sharedResponses = [];
+    for (const response of responses) {
+      const { statusCode, name, isShared, body, header } = response;
+      if (isShared) {
+        const sharedResponse = context.resources.sharedResponseResources.find(
+          (resource2) => {
+            return resource2.name === name;
+          }
+        );
+        if (!sharedResponse) {
+          throw new Error(
+            `Shared response '${response.name}' not found in shared resources`
+          );
+        }
+        sharedResponses.push({
+          name,
+          path: Path.relative(
+            outputDir,
+            `${sharedResponse.outputDir}/${path.basename(sharedResponse.outputFileName, ".ts")}`
+          )
+        });
+        continue;
+      }
+      ownResponses.push({
+        name,
+        body: body ? TsTypePrinter.print(TsTypeNode.fromZod(body)) : void 0,
+        header: header ? TsTypePrinter.print(TsTypeNode.fromZod(header)) : void 0,
+        statusCode,
+        statusCodeKey: HttpStatusCode[statusCode]
+      });
+    }
+    const content = context.renderTemplate(templateFile, {
+      operationId,
+      pascalCaseOperationId,
+      coreDir: context.coreDir,
+      ownResponses,
+      sharedResponses,
+      responseFile: Path.relative(
+        outputDir,
+        `${outputDir}/${path.basename(outputResponseFileName, ".ts")}`
+      ),
+      sourcePath: Path.relative(
+        outputDir,
+        `${sourceDir}/${path.basename(sourceFile, ".ts")}`
+      )
+    });
+    const relativePath = path.relative(context.outputDir, outputResponseFile);
+    context.writeFile(relativePath, content);
+  }
+}
+
+const __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
+class ResponseValidationGenerator {
+  static generate(context) {
+    const templateFilePath = path.join(
+      __dirname$1,
+      "templates",
+      "ResponseValidator.ejs"
+    );
+    for (const [, operationResources] of Object.entries(
+      context.resources.entityResources
+    )) {
+      for (const operationResource of operationResources) {
+        this.writeResponseValidator(templateFilePath, operationResource, context);
+      }
+    }
+  }
+  static writeResponseValidator(templateFilePath, resource, context) {
+    const {
+      definition,
+      outputDir,
+      outputResponseFileName,
+      sourceDir,
+      sourceFile,
+      outputResponseValidationFile
+    } = resource;
+    const { responses, operationId } = definition;
+    const pascalCaseOperationId = Case.pascal(operationId);
+    const ownResponses = [];
+    const sharedResponses = [];
+    const allStatusCodes = [];
+    for (const response of responses) {
+      const { statusCode, name, isShared, body, header, statusCodeName } = response;
+      const index = responses.indexOf(response);
+      const isStatusCodeIncluded = allStatusCodes.some((status) => {
+        return status.statusCode === statusCode;
+      });
+      if (!isStatusCodeIncluded) {
+        allStatusCodes.push({
+          statusCode,
+          name: statusCodeName
+        });
+      }
+      if (isShared) {
+        const sharedResponse = context.resources.sharedResponseResources.find(
+          (resource2) => {
+            return resource2.name === name;
+          }
+        );
+        if (!sharedResponse) {
+          throw new Error(
+            `Shared response '${response.name}' not found in shared resources`
+          );
+        }
+        sharedResponses.push({
+          name,
+          importPath: Path.relative(
+            outputDir,
+            `${sharedResponse.outputDir}/${path.basename(sharedResponse.outputFileName, ".ts")}`
+          ),
+          hasBody: !!body,
+          hasHeader: !!header,
+          statusCode,
+          index
+        });
+        continue;
+      }
+      ownResponses.push({
+        name,
+        hasBody: !!body,
+        hasHeader: !!header,
+        statusCode,
+        statusCodeKey: HttpStatusCode[statusCode],
+        index
+      });
+    }
+    const content = context.renderTemplate(templateFilePath, {
+      operationId,
+      pascalCaseOperationId,
+      coreDir: context.coreDir,
+      responseFile: `./${path.basename(outputResponseFileName, ".ts")}`,
+      sourcePath: Path.relative(
+        outputDir,
+        `${sourceDir}/${path.basename(sourceFile, ".ts")}`
+      ),
+      sharedResponses,
+      ownResponses,
+      allStatusCodes
+    });
+    const relativePath = path.relative(context.outputDir, outputResponseValidationFile);
+    context.writeFile(relativePath, content);
+  }
+}
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+class TypesPlugin extends BasePlugin {
+  name = "types";
+  generate(context) {
+    const libDir = path.join(__dirname, "lib");
+    this.copyLibFiles(context, libDir, this.name);
+    SharedResponseGenerator.generate(context);
+    RequestGenerator.generate(context);
+    RequestValidationGenerator.generate(context);
+    ResponseGenerator.generate(context);
+    ResponseValidationGenerator.generate(context);
+  }
+}
+
+export { TypesPlugin as default };