@forklaunch/implementation-worker-kafka 0.3.7 → 0.4.0

package/lib/domain/schemas/index.mjs

@@ -1,18 +1,7 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -26,443 +15,11 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// ../../../node_modules/.pnpm/ts-deepmerge@6.2.1/node_modules/ts-deepmerge/cjs/index.js
-var require_cjs = __commonJS({
-  "../../../node_modules/.pnpm/ts-deepmerge@6.2.1/node_modules/ts-deepmerge/cjs/index.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    var isObject = (obj) => {
-      if (typeof obj === "object" && obj !== null) {
-        if (typeof Object.getPrototypeOf === "function") {
-          const prototype = Object.getPrototypeOf(obj);
-          return prototype === Object.prototype || prototype === null;
-        }
-        return Object.prototype.toString.call(obj) === "[object Object]";
-      }
-      return false;
-    };
-    var merge = (...objects) => objects.reduce((result, current) => {
-      if (Array.isArray(current)) {
-        throw new TypeError("Arguments provided to ts-deepmerge must be objects, not arrays.");
-      }
-      Object.keys(current).forEach((key) => {
-        if (["__proto__", "constructor", "prototype"].includes(key)) {
-          return;
-        }
-        if (Array.isArray(result[key]) && Array.isArray(current[key])) {
-          result[key] = merge.options.mergeArrays ? merge.options.uniqueArrayItems ? Array.from(new Set(result[key].concat(current[key]))) : [...result[key], ...current[key]] : current[key];
-        } else if (isObject(result[key]) && isObject(current[key])) {
-          result[key] = merge(result[key], current[key]);
-        } else {
-          result[key] = current[key] === void 0 ? merge.options.allowUndefinedOverrides ? current[key] : result[key] : current[key];
-        }
-      });
-      return result;
-    }, {});
-    var defaultOptions = {
-      allowUndefinedOverrides: true,
-      mergeArrays: true,
-      uniqueArrayItems: true
-    };
-    merge.options = defaultOptions;
-    merge.withOptions = (options, ...objects) => {
-      merge.options = Object.assign(Object.assign({}, defaultOptions), options);
-      const result = merge(...objects);
-      merge.options = defaultOptions;
-      return result;
-    };
-    exports.default = merge;
-  }
-});
-
-// ../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.5.0_zod@3.25.76/node_modules/@anatine/zod-openapi/src/lib/zod-openapi.js
-var require_zod_openapi = __commonJS({
-  "../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.5.0_zod@3.25.76/node_modules/@anatine/zod-openapi/src/lib/zod-openapi.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.generateSchema = exports.extendApi = void 0;
-    var ts_deepmerge_1 = require_cjs();
-    var zod_1 = __require("zod");
-    function extendApi(schema, schemaObject = {}) {
-      const This = schema.constructor;
-      const newSchema = new This(schema._def);
-      newSchema.metaOpenApi = Object.assign({}, schema.metaOpenApi || {}, schemaObject);
-      return newSchema;
-    }
-    exports.extendApi = extendApi;
-    function iterateZodObject({ zodRef, useOutput, hideDefinitions, openApiVersion }) {
-      const reduced = Object.keys(zodRef.shape).filter((key) => (hideDefinitions === null || hideDefinitions === void 0 ? void 0 : hideDefinitions.includes(key)) === false).reduce((carry, key) => Object.assign(Object.assign({}, carry), { [key]: generateSchema2(zodRef.shape[key], useOutput, openApiVersion) }), {});
-      return reduced;
-    }
-    function typeFormat(type3, openApiVersion) {
-      return openApiVersion === "3.0" ? type3 : [type3];
-    }
-    function parseTransformation({ zodRef, schemas, useOutput, openApiVersion }) {
-      const input = generateSchema2(zodRef._def.schema, useOutput, openApiVersion);
-      let output = "undefined";
-      if (useOutput && zodRef._def.effect) {
-        const effect = zodRef._def.effect.type === "transform" ? zodRef._def.effect : null;
-        if (effect && "transform" in effect) {
-          try {
-            const type3 = Array.isArray(input.type) ? input.type[0] : input.type;
-            output = typeof effect.transform(
-              ["integer", "number"].includes(`${type3}`) ? 0 : "string" === type3 ? "" : "boolean" === type3 ? false : "object" === type3 ? {} : "null" === type3 ? null : "array" === type3 ? [] : void 0,
-              { addIssue: () => void 0, path: [] }
-              // TODO: Discover if context is necessary here
-            );
-          } catch (e) {
-          }
-        }
-      }
-      const outputType = output;
-      return (0, ts_deepmerge_1.default)(Object.assign(Object.assign(Object.assign({}, zodRef.description ? { description: zodRef.description } : {}), input), ["number", "string", "boolean", "null"].includes(output) ? {
-        type: typeFormat(outputType, openApiVersion)
-      } : {}), ...schemas);
-    }
-    function parseString({ zodRef, schemas, openApiVersion }) {
-      const baseSchema = {
-        type: typeFormat("string", openApiVersion)
-      };
-      const { checks = [] } = zodRef._def;
-      checks.forEach((item) => {
-        switch (item.kind) {
-          case "email":
-            baseSchema.format = "email";
-            break;
-          case "uuid":
-            baseSchema.format = "uuid";
-            break;
-          case "cuid":
-            baseSchema.format = "cuid";
-            break;
-          case "url":
-            baseSchema.format = "uri";
-            break;
-          case "datetime":
-            baseSchema.format = "date-time";
-            break;
-          case "length":
-            baseSchema.minLength = item.value;
-            baseSchema.maxLength = item.value;
-            break;
-          case "max":
-            baseSchema.maxLength = item.value;
-            break;
-          case "min":
-            baseSchema.minLength = item.value;
-            break;
-          case "regex":
-            baseSchema.pattern = item.regex.source;
-            break;
-        }
-      });
-      return (0, ts_deepmerge_1.default)(baseSchema, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseNumber({ zodRef, schemas, openApiVersion }) {
-      const baseSchema = {
-        type: typeFormat("number", openApiVersion)
-      };
-      const { checks = [] } = zodRef._def;
-      checks.forEach((item) => {
-        switch (item.kind) {
-          case "max":
-            if (item.inclusive || openApiVersion === "3.0") {
-              baseSchema.maximum = item.value;
-            }
-            if (!item.inclusive) {
-              if (openApiVersion === "3.0") {
-                baseSchema.exclusiveMaximum = true;
-              } else {
-                baseSchema.exclusiveMaximum = item.value;
-              }
-            }
-            break;
-          case "min":
-            if (item.inclusive || openApiVersion === "3.0") {
-              baseSchema.minimum = item.value;
-            }
-            if (!item.inclusive) {
-              if (openApiVersion === "3.0") {
-                baseSchema.exclusiveMinimum = true;
-              } else {
-                baseSchema.exclusiveMinimum = item.value;
-              }
-            }
-            break;
-          case "int":
-            baseSchema.type = typeFormat("integer", openApiVersion);
-            break;
-          case "multipleOf":
-            baseSchema.multipleOf = item.value;
-            break;
-        }
-      });
-      return (0, ts_deepmerge_1.default)(baseSchema, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function getExcludedDefinitionsFromSchema(schemas) {
-      const excludedDefinitions = [];
-      for (const schema of schemas) {
-        if (Array.isArray(schema.hideDefinitions)) {
-          excludedDefinitions.push(...schema.hideDefinitions);
-        }
-      }
-      return excludedDefinitions;
-    }
-    function parseObject({ zodRef, schemas, useOutput, hideDefinitions, openApiVersion }) {
-      var _a;
-      let additionalProperties;
-      if (!(zodRef._def.catchall instanceof zod_1.z.ZodNever || ((_a = zodRef._def.catchall) === null || _a === void 0 ? void 0 : _a._def.typeName) === "ZodNever"))
-        additionalProperties = generateSchema2(zodRef._def.catchall, useOutput, openApiVersion);
-      else if (zodRef._def.unknownKeys === "passthrough")
-        additionalProperties = true;
-      else if (zodRef._def.unknownKeys === "strict")
-        additionalProperties = false;
-      additionalProperties = additionalProperties != null ? { additionalProperties } : {};
-      const requiredProperties = Object.keys(zodRef.shape).filter((key) => {
-        const item = zodRef.shape[key];
-        return !(item.isOptional() || item instanceof zod_1.z.ZodDefault || item._def.typeName === "ZodDefault") && !(item instanceof zod_1.z.ZodNever || item._def.typeName === "ZodDefault");
-      });
-      const required = requiredProperties.length > 0 ? { required: requiredProperties } : {};
-      return (0, ts_deepmerge_1.default)(Object.assign(Object.assign(Object.assign({ type: typeFormat("object", openApiVersion), properties: iterateZodObject({
-        zodRef,
-        schemas,
-        useOutput,
-        hideDefinitions: getExcludedDefinitionsFromSchema(schemas),
-        openApiVersion
-      }) }, required), additionalProperties), hideDefinitions), zodRef.description ? { description: zodRef.description, hideDefinitions } : {}, ...schemas);
-    }
-    function parseRecord({ zodRef, schemas, useOutput, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)({
-        type: typeFormat("object", openApiVersion),
-        additionalProperties: zodRef._def.valueType instanceof zod_1.z.ZodUnknown ? {} : generateSchema2(zodRef._def.valueType, useOutput, openApiVersion)
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseBigInt({ zodRef, schemas, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)({
-        type: typeFormat("integer", openApiVersion),
-        format: "int64"
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseBoolean({ zodRef, schemas, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)({ type: typeFormat("boolean", openApiVersion) }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseDate({ zodRef, schemas, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)({
-        type: typeFormat("string", openApiVersion),
-        format: "date-time"
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseNull({ zodRef, schemas, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)(openApiVersion === "3.0" ? { type: "null" } : {
-        type: ["string", "null"],
-        enum: ["null"]
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseOptional({ schemas, zodRef, useOutput, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)(generateSchema2(zodRef.unwrap(), useOutput, openApiVersion), zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseNullable({ schemas, zodRef, useOutput, openApiVersion }) {
-      const schema = generateSchema2(zodRef.unwrap(), useOutput, openApiVersion);
-      return (0, ts_deepmerge_1.default)(schema, openApiVersion === "3.0" ? { nullable: true } : { type: typeFormat("null", openApiVersion) }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseDefault({ schemas, zodRef, useOutput, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)(Object.assign({ default: zodRef._def.defaultValue() }, generateSchema2(zodRef._def.innerType, useOutput, openApiVersion)), zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseArray({ schemas, zodRef, useOutput, openApiVersion }) {
-      const constraints = {};
-      if (zodRef._def.exactLength != null) {
-        constraints.minItems = zodRef._def.exactLength.value;
-        constraints.maxItems = zodRef._def.exactLength.value;
-      }
-      if (zodRef._def.minLength != null)
-        constraints.minItems = zodRef._def.minLength.value;
-      if (zodRef._def.maxLength != null)
-        constraints.maxItems = zodRef._def.maxLength.value;
-      return (0, ts_deepmerge_1.default)(Object.assign({ type: typeFormat("array", openApiVersion), items: generateSchema2(zodRef.element, useOutput, openApiVersion) }, constraints), zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseLiteral({ schemas, zodRef, openApiVersion }) {
-      const type3 = typeof zodRef._def.value;
-      return (0, ts_deepmerge_1.default)({
-        type: typeFormat(type3, openApiVersion),
-        enum: [zodRef._def.value]
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseEnum({ schemas, zodRef, openApiVersion }) {
-      const type3 = typeof Object.values(zodRef._def.values)[0];
-      return (0, ts_deepmerge_1.default)({
-        type: typeFormat(type3, openApiVersion),
-        enum: Object.values(zodRef._def.values)
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseIntersection({ schemas, zodRef, useOutput, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)({
-        allOf: [
-          generateSchema2(zodRef._def.left, useOutput, openApiVersion),
-          generateSchema2(zodRef._def.right, useOutput, openApiVersion)
-        ]
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseUnion({ schemas, zodRef, useOutput, openApiVersion }) {
-      const contents = zodRef._def.options;
-      if (contents.reduce((prev, content) => prev && content._def.typeName === "ZodLiteral", true)) {
-        const literals = contents;
-        const type3 = literals.reduce((prev, content) => !prev || prev === typeof content._def.value ? typeof content._def.value : null, null);
-        if (type3) {
-          return (0, ts_deepmerge_1.default)({
-            type: typeFormat(type3, openApiVersion),
-            enum: literals.map((literal3) => literal3._def.value)
-          }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-        }
-      }
-      const oneOfContents = openApiVersion === "3.0" ? contents.filter((content) => content._def.typeName !== "ZodNull") : contents;
-      const contentsHasNull = contents.length != oneOfContents.length;
-      return (0, ts_deepmerge_1.default)({
-        oneOf: oneOfContents.map((schema) => generateSchema2(schema, useOutput, openApiVersion))
-      }, contentsHasNull ? { nullable: true } : {}, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseDiscriminatedUnion({ schemas, zodRef, useOutput, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)({
-        discriminator: {
-          propertyName: zodRef._def.discriminator
-        },
-        oneOf: Array.from(zodRef._def.options.values()).map((schema) => generateSchema2(schema, useOutput, openApiVersion))
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseNever({ zodRef, schemas }) {
-      return (0, ts_deepmerge_1.default)({ readOnly: true }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseBranded({ schemas, zodRef, useOutput, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)(generateSchema2(zodRef._def.type, useOutput, openApiVersion), ...schemas);
-    }
-    function catchAllParser({ zodRef, schemas }) {
-      return (0, ts_deepmerge_1.default)(zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parsePipeline({ schemas, zodRef, useOutput, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)(generateSchema2(useOutput ? zodRef._def.out : zodRef._def.in, useOutput, openApiVersion), ...schemas);
-    }
-    function parseReadonly({ zodRef, useOutput, schemas, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)(generateSchema2(zodRef._def.innerType, useOutput, openApiVersion), zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    var workerMap = {
-      ZodObject: parseObject,
-      ZodRecord: parseRecord,
-      ZodString: parseString,
-      ZodNumber: parseNumber,
-      ZodBigInt: parseBigInt,
-      ZodBoolean: parseBoolean,
-      ZodDate: parseDate,
-      ZodNull: parseNull,
-      ZodOptional: parseOptional,
-      ZodNullable: parseNullable,
-      ZodDefault: parseDefault,
-      ZodArray: parseArray,
-      ZodLiteral: parseLiteral,
-      ZodEnum: parseEnum,
-      ZodNativeEnum: parseEnum,
-      ZodTransformer: parseTransformation,
-      ZodEffects: parseTransformation,
-      ZodIntersection: parseIntersection,
-      ZodUnion: parseUnion,
-      ZodDiscriminatedUnion: parseDiscriminatedUnion,
-      ZodNever: parseNever,
-      ZodBranded: parseBranded,
-      // TODO Transform the rest to schemas
-      ZodUndefined: catchAllParser,
-      // TODO: `prefixItems` is allowed in OpenAPI 3.1 which can be used to create tuples
-      ZodTuple: catchAllParser,
-      ZodMap: catchAllParser,
-      ZodFunction: catchAllParser,
-      ZodLazy: catchAllParser,
-      ZodPromise: catchAllParser,
-      ZodAny: catchAllParser,
-      ZodUnknown: catchAllParser,
-      ZodVoid: catchAllParser,
-      ZodPipeline: parsePipeline,
-      ZodReadonly: parseReadonly
-    };
-    function generateSchema2(zodRef, useOutput = false, openApiVersion = "3.1") {
-      const { metaOpenApi = {} } = zodRef;
-      const schemas = [
-        ...Array.isArray(metaOpenApi) ? metaOpenApi : [metaOpenApi]
-      ];
-      try {
-        const typeName = zodRef._def.typeName;
-        if (typeName in workerMap) {
-          return workerMap[typeName]({
-            zodRef,
-            schemas,
-            useOutput,
-            openApiVersion
-          });
-        }
-        return catchAllParser({ zodRef, schemas, openApiVersion });
-      } catch (err) {
-        console.error(err);
-        return catchAllParser({ zodRef, schemas, openApiVersion });
-      }
-    }
-    exports.generateSchema = generateSchema2;
-  }
-});
-
-// ../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.5.0_zod@3.25.76/node_modules/@anatine/zod-openapi/src/lib/zod-extensions.js
-var require_zod_extensions = __commonJS({
-  "../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.5.0_zod@3.25.76/node_modules/@anatine/zod-openapi/src/lib/zod-extensions.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.extendZodWithOpenApi = void 0;
-    var zod_openapi_1 = require_zod_openapi();
-    function extendZodWithOpenApi2(zod, forceOverride = false) {
-      if (!forceOverride && typeof zod.ZodSchema.prototype.openapi !== "undefined") {
-        return;
-      }
-      zod.ZodSchema.prototype.openapi = function(metadata) {
-        return (0, zod_openapi_1.extendApi)(this, metadata);
-      };
-    }
-    exports.extendZodWithOpenApi = extendZodWithOpenApi2;
-  }
-});
-
-// ../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.5.0_zod@3.25.76/node_modules/@anatine/zod-openapi/src/index.js
-var require_src = __commonJS({
-  "../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.5.0_zod@3.25.76/node_modules/@anatine/zod-openapi/src/index.js"(exports) {
-    "use strict";
-    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    } : function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    });
-    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
-      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
-    };
-    Object.defineProperty(exports, "__esModule", { value: true });
-    __exportStar(require_zod_openapi(), exports);
-    __exportStar(require_zod_extensions(), exports);
-  }
-});
 
 // domain/schemas/kafka.schema.ts
 import { serviceSchemaResolver } from "@forklaunch/internal";
 
-// ../../../node_modules/.pnpm/@forklaunch+validator@0.7.5_openapi3-ts@4.5.0/node_modules/@forklaunch/validator/lib/src/typebox/index.mjs
+// ../../../node_modules/.pnpm/@forklaunch+validator@0.7.7/node_modules/@forklaunch/validator/lib/src/typebox/index.mjs
 var typebox_exports = {};
 __export(typebox_exports, {
   SchemaValidator: () => SchemaValidator,
@@ -503,7 +60,7 @@ __export(typebox_exports, {
 __reExport(typebox_exports, typebox_star);
 import * as typebox_star from "@sinclair/typebox";
 
-// ../../../node_modules/.pnpm/@forklaunch+common@0.4.3/node_modules/@forklaunch/common/lib/index.mjs
+// ../../../node_modules/.pnpm/@forklaunch+common@0.4.5/node_modules/@forklaunch/common/lib/index.mjs
 var InMemoryBlob = class extends Blob {
   constructor(content) {
     super([Buffer.from(content)]);
@@ -511,7 +68,7 @@ var InMemoryBlob = class extends Blob {
   }
 };
 
-// ../../../node_modules/.pnpm/@forklaunch+validator@0.7.5_openapi3-ts@4.5.0/node_modules/@forklaunch/validator/lib/src/typebox/index.mjs
+// ../../../node_modules/.pnpm/@forklaunch+validator@0.7.7/node_modules/@forklaunch/validator/lib/src/typebox/index.mjs
 import {
   FormatRegistry,
   Kind,
@@ -1030,50 +587,672 @@ var KafkaWorkerOptionsSchema = {
   peekCount: number
 };
 
-// ../../../node_modules/.pnpm/@forklaunch+validator@0.7.5_openapi3-ts@4.5.0/node_modules/@forklaunch/validator/lib/src/zod/index.mjs
-var import_zod_openapi = __toESM(require_src(), 1);
+// ../../../node_modules/.pnpm/@forklaunch+validator@0.7.7/node_modules/@forklaunch/validator/lib/src/zod/index.mjs
 import {
-  z,
+  z as z2,
   ZodType
 } from "zod/v3";
-(0, import_zod_openapi.extendZodWithOpenApi)(z);
+
+// ../../../node_modules/.pnpm/ts-deepmerge@7.0.3/node_modules/ts-deepmerge/esm/index.js
+var isObject = (obj) => {
+  if (typeof obj === "object" && obj !== null) {
+    if (typeof Object.getPrototypeOf === "function") {
+      const prototype = Object.getPrototypeOf(obj);
+      return prototype === Object.prototype || prototype === null;
+    }
+    return Object.prototype.toString.call(obj) === "[object Object]";
+  }
+  return false;
+};
+var merge = (...objects) => objects.reduce((result, current) => {
+  if (current === void 0) {
+    return result;
+  }
+  if (Array.isArray(current)) {
+    throw new TypeError("Arguments provided to ts-deepmerge must be objects, not arrays.");
+  }
+  Object.keys(current).forEach((key) => {
+    if (["__proto__", "constructor", "prototype"].includes(key)) {
+      return;
+    }
+    if (Array.isArray(result[key]) && Array.isArray(current[key])) {
+      result[key] = merge.options.mergeArrays ? merge.options.uniqueArrayItems ? Array.from(new Set(result[key].concat(current[key]))) : [...result[key], ...current[key]] : current[key];
+    } else if (isObject(result[key]) && isObject(current[key])) {
+      result[key] = merge(result[key], current[key]);
+    } else if (!isObject(result[key]) && isObject(current[key])) {
+      result[key] = merge(current[key], void 0);
+    } else {
+      result[key] = current[key] === void 0 ? merge.options.allowUndefinedOverrides ? current[key] : result[key] : current[key];
+    }
+  });
+  return result;
+}, {});
+var defaultOptions = {
+  allowUndefinedOverrides: true,
+  mergeArrays: true,
+  uniqueArrayItems: true
+};
+merge.options = defaultOptions;
+merge.withOptions = (options, ...objects) => {
+  merge.options = Object.assign(Object.assign({}, defaultOptions), options);
+  const result = merge(...objects);
+  merge.options = defaultOptions;
+  return result;
+};
+
+// ../../../node_modules/.pnpm/@forklaunch+validator@0.7.7/node_modules/@forklaunch/validator/lib/src/zod/index.mjs
+import { z } from "zod/v3";
+function extendApi(schema, schemaObject = {}) {
+  const This = schema.constructor;
+  const newSchema = new This(schema._def);
+  newSchema.metaOpenApi = Object.assign(
+    {},
+    schema.metaOpenApi || {},
+    schemaObject
+  );
+  return newSchema;
+}
+function iterateZodObject({
+  zodRef,
+  useOutput,
+  hideDefinitions,
+  openApiVersion
+}) {
+  const reduced = Object.keys(zodRef.shape).filter((key) => hideDefinitions?.includes(key) === false).reduce(
+    (carry, key) => ({
+      ...carry,
+      [key]: generateSchema(zodRef.shape[key], useOutput, openApiVersion)
+    }),
+    {}
+  );
+  return reduced;
+}
+function typeFormat(type22, openApiVersion) {
+  return openApiVersion === "3.0" ? type22 : [type22];
+}
+function parseTransformation({
+  zodRef,
+  schemas,
+  useOutput,
+  openApiVersion
+}) {
+  const input = generateSchema(zodRef._def.schema, useOutput, openApiVersion);
+  let output = "undefined";
+  if (useOutput && zodRef._def.effect) {
+    const effect = zodRef._def.effect.type === "transform" ? zodRef._def.effect : null;
+    if (effect && "transform" in effect) {
+      try {
+        const type22 = Array.isArray(input.type) ? input.type[0] : input.type;
+        output = typeof effect.transform(
+          ["integer", "number"].includes(`${type22}`) ? 0 : "string" === type22 ? "" : "boolean" === type22 ? false : "object" === type22 ? {} : "null" === type22 ? null : "array" === type22 ? [] : void 0,
+          { addIssue: () => void 0, path: [] }
+          // TODO: Discover if context is necessary here
+        );
+      } catch {
+      }
+    }
+  }
+  const outputType = output;
+  return merge(
+    {
+      ...zodRef.description ? { description: zodRef.description } : {},
+      ...input,
+      ...["number", "string", "boolean", "null"].includes(output) ? {
+        type: typeFormat(outputType, openApiVersion)
+      } : {}
+    },
+    ...schemas
+  );
+}
+function parseString({
+  zodRef,
+  schemas,
+  openApiVersion
+}) {
+  const baseSchema = {
+    type: typeFormat("string", openApiVersion)
+  };
+  const { checks = [] } = zodRef._def;
+  checks.forEach((item) => {
+    switch (item.kind) {
+      case "email":
+        baseSchema.format = "email";
+        break;
+      case "uuid":
+        baseSchema.format = "uuid";
+        break;
+      case "cuid":
+        baseSchema.format = "cuid";
+        break;
+      case "url":
+        baseSchema.format = "uri";
+        break;
+      case "datetime":
+        baseSchema.format = "date-time";
+        break;
+      case "length":
+        baseSchema.minLength = item.value;
+        baseSchema.maxLength = item.value;
+        break;
+      case "max":
+        baseSchema.maxLength = item.value;
+        break;
+      case "min":
+        baseSchema.minLength = item.value;
+        break;
+      case "regex":
+        baseSchema.pattern = item.regex.source;
+        break;
+    }
+  });
+  return merge(
+    baseSchema,
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseNumber({
+  zodRef,
+  schemas,
+  openApiVersion
+}) {
+  const baseSchema = {
+    type: typeFormat("number", openApiVersion)
+  };
+  const { checks = [] } = zodRef._def;
+  checks.forEach((item) => {
+    switch (item.kind) {
+      case "max":
+        if (item.inclusive || openApiVersion === "3.0") {
+          baseSchema.maximum = item.value;
+        }
+        if (!item.inclusive) {
+          if (openApiVersion === "3.0") {
+            baseSchema.exclusiveMaximum = true;
+          } else {
+            baseSchema.exclusiveMaximum = item.value;
+          }
+        }
+        break;
+      case "min":
+        if (item.inclusive || openApiVersion === "3.0") {
+          baseSchema.minimum = item.value;
+        }
+        if (!item.inclusive) {
+          if (openApiVersion === "3.0") {
+            baseSchema.exclusiveMinimum = true;
+          } else {
+            baseSchema.exclusiveMinimum = item.value;
+          }
+        }
+        break;
+      case "int":
+        baseSchema.type = typeFormat("integer", openApiVersion);
+        break;
+      case "multipleOf":
+        baseSchema.multipleOf = item.value;
+        break;
+    }
+  });
+  return merge(
+    baseSchema,
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function getExcludedDefinitionsFromSchema(schemas) {
+  const excludedDefinitions = [];
+  for (const schema of schemas) {
+    if (Array.isArray(schema.hideDefinitions)) {
+      excludedDefinitions.push(...schema.hideDefinitions);
+    }
+  }
+  return excludedDefinitions;
+}
+function parseObject({
+  zodRef,
+  schemas,
+  useOutput,
+  hideDefinitions,
+  openApiVersion
+}) {
+  let additionalProperties;
+  if (!(zodRef._def.catchall instanceof z.ZodNever || zodRef._def.catchall?._def.typeName === "ZodNever"))
+    additionalProperties = generateSchema(
+      zodRef._def.catchall,
+      useOutput,
+      openApiVersion
+    );
+  else if (zodRef._def.unknownKeys === "passthrough")
+    additionalProperties = true;
+  else if (zodRef._def.unknownKeys === "strict") additionalProperties = false;
+  additionalProperties = additionalProperties != null ? { additionalProperties } : {};
+  const requiredProperties = Object.keys(
+    zodRef.shape
+  ).filter((key) => {
+    const item = zodRef.shape[key];
+    return !(item.isOptional() || item instanceof z.ZodDefault || item._def.typeName === "ZodDefault") && !(item instanceof z.ZodNever || item._def.typeName === "ZodDefault");
+  });
+  const required = requiredProperties.length > 0 ? { required: requiredProperties } : {};
+  return merge(
+    {
+      type: typeFormat("object", openApiVersion),
+      properties: iterateZodObject({
+        zodRef,
+        schemas,
+        useOutput,
+        hideDefinitions: getExcludedDefinitionsFromSchema(schemas),
+        openApiVersion
+      }),
+      ...required,
+      ...additionalProperties,
+      ...hideDefinitions
+    },
+    zodRef.description ? { description: zodRef.description, hideDefinitions } : {},
+    ...schemas
+  );
+}
+function parseRecord({
+  zodRef,
+  schemas,
+  useOutput,
+  openApiVersion
+}) {
+  return merge(
+    {
+      type: typeFormat("object", openApiVersion),
+      additionalProperties: zodRef._def.valueType instanceof z.ZodUnknown ? {} : generateSchema(zodRef._def.valueType, useOutput, openApiVersion)
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseBigInt({
+  zodRef,
+  schemas,
+  openApiVersion
+}) {
+  return merge(
+    {
+      type: typeFormat("integer", openApiVersion),
+      format: "int64"
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseBoolean({
+  zodRef,
+  schemas,
+  openApiVersion
+}) {
+  return merge(
+    { type: typeFormat("boolean", openApiVersion) },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseDate({
+  zodRef,
+  schemas,
+  openApiVersion
+}) {
+  return merge(
+    {
+      type: typeFormat("string", openApiVersion),
+      format: "date-time"
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseNull({
+  zodRef,
+  schemas,
+  openApiVersion
+}) {
+  return merge(
+    openApiVersion === "3.0" ? { type: "null" } : {
+      type: ["string", "null"],
+      enum: ["null"]
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseOptional({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  return merge(
+    generateSchema(zodRef.unwrap(), useOutput, openApiVersion),
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseNullable({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  const schema = generateSchema(zodRef.unwrap(), useOutput, openApiVersion);
+  return merge(
+    schema,
+    openApiVersion === "3.0" ? { nullable: true } : { type: typeFormat("null", openApiVersion) },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseDefault({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  return merge(
+    {
+      default: zodRef._def.defaultValue(),
+      ...generateSchema(zodRef._def.innerType, useOutput, openApiVersion)
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseArray({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  const constraints = {};
+  if (zodRef._def.exactLength != null) {
+    constraints.minItems = zodRef._def.exactLength.value;
+    constraints.maxItems = zodRef._def.exactLength.value;
+  }
+  if (zodRef._def.minLength != null)
+    constraints.minItems = zodRef._def.minLength.value;
+  if (zodRef._def.maxLength != null)
+    constraints.maxItems = zodRef._def.maxLength.value;
+  return merge(
+    {
+      type: typeFormat("array", openApiVersion),
+      items: generateSchema(zodRef.element, useOutput, openApiVersion),
+      ...constraints
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseLiteral({
+  schemas,
+  zodRef,
+  openApiVersion
+}) {
+  const type22 = typeof zodRef._def.value;
+  return merge(
+    {
+      type: typeFormat(type22, openApiVersion),
+      enum: [zodRef._def.value]
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseEnum({
+  schemas,
+  zodRef,
+  openApiVersion
+}) {
+  const type22 = typeof Object.values(zodRef._def.values)[0];
+  return merge(
+    {
+      type: typeFormat(type22, openApiVersion),
+      enum: Object.values(zodRef._def.values)
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseIntersection({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  return merge(
+    {
+      allOf: [
+        generateSchema(zodRef._def.left, useOutput, openApiVersion),
+        generateSchema(zodRef._def.right, useOutput, openApiVersion)
+      ]
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseUnion({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  const contents = zodRef._def.options;
+  if (contents.reduce(
+    (prev, content) => prev && content._def.typeName === "ZodLiteral",
+    true
+  )) {
+    const literals = contents;
+    const type22 = literals.reduce(
+      (prev, content) => !prev || prev === typeof content._def.value ? typeof content._def.value : null,
+      null
+    );
+    if (type22) {
+      return merge(
+        {
+          type: typeFormat(type22, openApiVersion),
+          enum: literals.map((literal22) => literal22._def.value)
+        },
+        zodRef.description ? { description: zodRef.description } : {},
+        ...schemas
+      );
+    }
+  }
+  const oneOfContents = openApiVersion === "3.0" ? contents.filter((content) => content._def.typeName !== "ZodNull") : contents;
+  const contentsHasNull = contents.length != oneOfContents.length;
+  return merge(
+    {
+      oneOf: oneOfContents.map(
+        (schema) => generateSchema(schema, useOutput, openApiVersion)
+      )
+    },
+    contentsHasNull ? { nullable: true } : {},
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseDiscriminatedUnion({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  return merge(
+    {
+      discriminator: {
+        propertyName: zodRef._def.discriminator
+      },
+      oneOf: Array.from(
+        zodRef._def.options.values()
+      ).map((schema) => generateSchema(schema, useOutput, openApiVersion))
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseNever({
+  zodRef,
+  schemas
+}) {
+  return merge(
+    { readOnly: true },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseBranded({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  return merge(
+    generateSchema(zodRef._def.type, useOutput, openApiVersion),
+    ...schemas
+  );
+}
+function catchAllParser({
+  zodRef,
+  schemas
+}) {
+  return merge(
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parsePipeline({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  return merge(
+    generateSchema(
+      useOutput ? zodRef._def.out : zodRef._def.in,
+      useOutput,
+      openApiVersion
+    ),
+    ...schemas
+  );
+}
+function parseReadonly({
+  zodRef,
+  useOutput,
+  schemas,
+  openApiVersion
+}) {
+  return merge(
+    generateSchema(zodRef._def.innerType, useOutput, openApiVersion),
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+var workerMap = {
+  ZodObject: parseObject,
+  ZodRecord: parseRecord,
+  ZodString: parseString,
+  ZodNumber: parseNumber,
+  ZodBigInt: parseBigInt,
+  ZodBoolean: parseBoolean,
+  ZodDate: parseDate,
+  ZodNull: parseNull,
+  ZodOptional: parseOptional,
+  ZodNullable: parseNullable,
+  ZodDefault: parseDefault,
+  ZodArray: parseArray,
+  ZodLiteral: parseLiteral,
+  ZodEnum: parseEnum,
+  ZodNativeEnum: parseEnum,
+  ZodTransformer: parseTransformation,
+  ZodEffects: parseTransformation,
+  ZodIntersection: parseIntersection,
+  ZodUnion: parseUnion,
+  ZodDiscriminatedUnion: parseDiscriminatedUnion,
+  ZodNever: parseNever,
+  ZodBranded: parseBranded,
+  // TODO Transform the rest to schemas
+  ZodUndefined: catchAllParser,
+  // TODO: `prefixItems` is allowed in OpenAPI 3.1 which can be used to create tuples
+  ZodTuple: catchAllParser,
+  ZodMap: catchAllParser,
+  ZodFunction: catchAllParser,
+  ZodLazy: catchAllParser,
+  ZodPromise: catchAllParser,
+  ZodAny: catchAllParser,
+  ZodUnknown: catchAllParser,
+  ZodVoid: catchAllParser,
+  ZodPipeline: parsePipeline,
+  ZodReadonly: parseReadonly
+};
+function generateSchema(zodRef, useOutput = false, openApiVersion = "3.1") {
+  const { metaOpenApi = {} } = zodRef;
+  const schemas = [
+    ...Array.isArray(metaOpenApi) ? metaOpenApi : [metaOpenApi]
+  ];
+  try {
+    const typeName = zodRef._def.typeName;
+    if (typeName in workerMap) {
+      return workerMap[typeName]({
+        zodRef,
+        schemas,
+        useOutput,
+        openApiVersion
+      });
+    }
+    return catchAllParser({ zodRef, schemas, openApiVersion });
+  } catch (err) {
+    console.error(err);
+    return catchAllParser({ zodRef, schemas, openApiVersion });
+  }
+}
+function extendZodWithOpenApi(zod, forceOverride = false) {
+  if (!forceOverride && typeof zod.ZodSchema.prototype.openapi !== "undefined") {
+    return;
+  }
+  zod.ZodSchema.prototype.openapi = function(metadata) {
+    return extendApi(this, metadata);
+  };
+}
+extendZodWithOpenApi(z2);
 var ZodSchemaValidator = class {
   _Type = "Zod";
   _SchemaCatchall;
   _ValidSchemaObject;
-  string = z.string().openapi({
+  string = z2.string().openapi({
     title: "String",
     example: "a string"
   });
-  uuid = z.string().uuid().openapi({
+  uuid = z2.string().uuid().openapi({
     title: "UUID",
     format: "uuid",
     pattern: "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$",
     example: "a8b2c3d4-e5f6-g7h8-i9j0-k1l2m3n4o5p6"
   });
-  email = z.string().email().openapi({
+  email = z2.string().email().openapi({
     title: "Email",
     format: "email",
     pattern: `(?:[a-z0-9!#$%&'*+/=?^_{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_{|}~-]+)*|"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)])`,
     example: "a@b.com"
   });
-  uri = z.string().url().openapi({
+  uri = z2.string().url().openapi({
     title: "URI",
     format: "uri",
     pattern: "^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$",
     example: "https://forklaunch.com"
   });
-  number = z.preprocess((value) => {
+  number = z2.preprocess((value) => {
     try {
       return Number(value);
     } catch {
       return value;
     }
-  }, z.number()).openapi({
+  }, z2.number()).openapi({
     title: "Number",
     example: 123
   });
-  bigint = z.preprocess((value) => {
+  bigint = z2.preprocess((value) => {
     try {
       if (value instanceof Date) {
         return BigInt(value.getTime());
@@ -1090,23 +1269,23 @@ var ZodSchemaValidator = class {
     } catch {
       return value;
     }
-  }, z.bigint()).openapi({
+  }, z2.bigint()).openapi({
     title: "BigInt",
     type: "integer",
     format: "int64",
     example: 123n
   });
-  boolean = z.preprocess((val) => {
+  boolean = z2.preprocess((val) => {
     if (typeof val === "string") {
       if (val.toLowerCase() === "true") return true;
       if (val.toLowerCase() === "false") return false;
     }
     return val;
-  }, z.boolean()).openapi({
+  }, z2.boolean()).openapi({
     title: "Boolean",
     example: true
   });
-  date = z.preprocess((value) => {
+  date = z2.preprocess((value) => {
     try {
       switch (typeof value) {
         case "string":
@@ -1119,58 +1298,58 @@ var ZodSchemaValidator = class {
     } catch {
       return value;
     }
-  }, z.date()).openapi({
+  }, z2.date()).openapi({
     title: "Date",
     type: "string",
     format: "date-time",
     example: "2025-05-16T21:13:04.123Z"
   });
-  symbol = z.symbol().openapi({
+  symbol = z2.symbol().openapi({
     title: "Symbol",
     example: Symbol("symbol")
   });
-  nullish = z.union([z.void(), z.null(), z.undefined()]).openapi({
+  nullish = z2.union([z2.void(), z2.null(), z2.undefined()]).openapi({
     title: "Nullish",
     type: "null",
     example: null
   });
-  void = z.void().openapi({
+  void = z2.void().openapi({
     title: "Void",
     type: "null",
     example: void 0
   });
-  null = z.null().openapi({
+  null = z2.null().openapi({
     title: "Null",
     type: "null",
     example: null
   });
-  undefined = z.undefined().openapi({
+  undefined = z2.undefined().openapi({
     title: "Undefined",
     type: "null",
     example: void 0
   });
-  any = z.any().openapi({
+  any = z2.any().openapi({
     title: "Any",
     type: "object",
     example: "any"
   });
-  unknown = z.unknown().openapi({
+  unknown = z2.unknown().openapi({
     title: "Unknown",
     type: "object",
     example: "unknown"
   });
-  never = z.never().openapi({
+  never = z2.never().openapi({
     title: "Never",
     type: "null",
     example: "never"
   });
-  binary = z.string().transform((v) => new TextEncoder().encode(v)).openapi({
+  binary = z2.string().transform((v) => new TextEncoder().encode(v)).openapi({
     title: "Binary",
     type: "string",
     format: "binary",
     example: "a utf-8 encodable string"
   });
-  file = z.string().transform((val) => {
+  file = z2.string().transform((val) => {
     return new Blob([val]);
   }).openapi({
     title: "File",
@@ -1195,7 +1374,7 @@ var ZodSchemaValidator = class {
    */
   schemify(schema) {
     if (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
-      return z.literal(schema);
+      return z2.literal(schema);
     }
     if (schema instanceof ZodType) {
       return schema;
@@ -1208,7 +1387,7 @@ var ZodSchemaValidator = class {
         newSchema[key] = this.schemify(schema[key]);
       }
     });
-    return z.object(newSchema);
+    return z2.object(newSchema);
   }
   /**
    * Make a schema optional.
@@ -1235,7 +1414,7 @@ var ZodSchemaValidator = class {
    */
   union(schemas) {
     const resolvedSchemas = schemas.map((schema) => this.schemify(schema));
-    return z.union(
+    return z2.union(
       resolvedSchemas
     );
   }
@@ -1245,7 +1424,7 @@ var ZodSchemaValidator = class {
    * @returns {ZodLiteral<ZodResolve<T>>} The literal schema.
    */
   literal(value) {
-    return z.literal(value);
+    return z2.literal(value);
   }
   /**
    * Create an enum schema.
@@ -1266,7 +1445,7 @@ var ZodSchemaValidator = class {
   function_(args, returnType) {
     const schemaArgs = args.map((schema) => this.schemify(schema));
     const schemaReturnType = this.schemify(returnType);
-    return z.function(z.tuple(schemaArgs), schemaReturnType);
+    return z2.function(z2.tuple(schemaArgs), schemaReturnType);
   }
   /**
    * Create a record schema.
@@ -1277,7 +1456,7 @@ var ZodSchemaValidator = class {
   record(key, value) {
     const keySchema = this.schemify(key);
     const valueSchema = this.schemify(value);
-    return z.record(keySchema, valueSchema);
+    return z2.record(keySchema, valueSchema);
   }
   /**
    * Create a promise schema.
@@ -1285,7 +1464,7 @@ var ZodSchemaValidator = class {
    * @returns {ZodPromise<ZodResolve<T>>} The promise schema.
    */
   promise(schema) {
-    return z.promise(this.schemify(schema));
+    return z2.promise(this.schemify(schema));
   }
   /**
    * Checks if a value is a Zod schema.
@@ -1356,7 +1535,7 @@ var ZodSchemaValidator = class {
    * @returns {SchemaObject} The OpenAPI schema object.
    */
   openapi(schema) {
-    return (0, import_zod_openapi.generateSchema)(this.schemify(schema));
+    return generateSchema(this.schemify(schema));
   }
 };
 var SchemaValidator2 = () => new ZodSchemaValidator();