@forklaunch/implementation-worker-bullmq 0.6.2 → 0.6.4

package/lib/domain/schemas/index.mjs

@@ -7,19 +7,25 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
+  if ((from && typeof from === 'object') || typeof from === 'function') {
     for (let key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __reExport = (target, mod, secondTarget) => (
+  __copyProps(target, mod, 'default'),
+  secondTarget && __copyProps(secondTarget, mod, 'default')
+);
 
 // domain/schemas/bullMqWorker.schema.ts
-import { serviceSchemaResolver } from "@forklaunch/internal";
+import { serviceSchemaResolver } from '@forklaunch/internal';
 
-// ../../../node_modules/.pnpm/@forklaunch+validator@0.10.5/node_modules/@forklaunch/validator/lib/src/typebox/index.mjs
+// ../../../node_modules/.pnpm/@forklaunch+validator@0.10.7/node_modules/@forklaunch/validator/lib/src/typebox/index.mjs
 var typebox_exports = {};
 __export(typebox_exports, {
   SchemaValidator: () => SchemaValidator,
@@ -58,9 +64,9 @@ __export(typebox_exports, {
   void_: () => void_
 });
 __reExport(typebox_exports, typebox_star);
-import * as typebox_star from "@sinclair/typebox";
+import * as typebox_star from '@sinclair/typebox';
 
-// ../../../node_modules/.pnpm/@forklaunch+common@0.6.5/node_modules/@forklaunch/common/lib/index.mjs
+// ../../../node_modules/.pnpm/@forklaunch+common@0.6.7/node_modules/@forklaunch/common/lib/index.mjs
 var InMemoryBlob = class extends Blob {
   constructor(content) {
     super([content]);
@@ -68,221 +74,229 @@ var InMemoryBlob = class extends Blob {
   }
 };
 
-// ../../../node_modules/.pnpm/@forklaunch+validator@0.10.5/node_modules/@forklaunch/validator/lib/src/typebox/index.mjs
-import {
-  FormatRegistry,
-  Kind,
-  KindGuard,
-  Type
-} from "@sinclair/typebox";
-import { TypeCheck, TypeCompiler } from "@sinclair/typebox/compiler";
+// ../../../node_modules/.pnpm/@forklaunch+validator@0.10.7/node_modules/@forklaunch/validator/lib/src/typebox/index.mjs
+import { FormatRegistry, Kind, KindGuard, Type } from '@sinclair/typebox';
+import { TypeCheck, TypeCompiler } from '@sinclair/typebox/compiler';
 import {
   DefaultErrorFunction,
   SetErrorFunction,
   ValueErrorType
-} from "@sinclair/typebox/errors";
-import { Value } from "@sinclair/typebox/value";
-FormatRegistry.Set("binary", (value) => typeof value === "string");
+} from '@sinclair/typebox/errors';
+import { Value } from '@sinclair/typebox/value';
+FormatRegistry.Set('binary', (value) => typeof value === 'string');
 SetErrorFunction((params) => {
   switch (params.errorType) {
     case ValueErrorType.Union:
     case ValueErrorType.Array:
     case ValueErrorType.String:
     case ValueErrorType.Number:
-      return params.schema.errorType ? `Expected ${params.schema.errorType} value${params.schema.errorSuffix ? "s" : ""}` : DefaultErrorFunction(params);
+      return params.schema.errorType
+        ? `Expected ${params.schema.errorType} value${params.schema.errorSuffix ? 's' : ''}`
+        : DefaultErrorFunction(params);
     default:
       return DefaultErrorFunction(params);
   }
 });
 var TypeboxSchemaValidator = class {
-  _Type = "TypeBox";
+  _Type = 'TypeBox';
   _SchemaCatchall;
   _ValidSchemaObject;
   string = Type.String({
-    example: "a string",
-    title: "String"
+    example: 'a string',
+    title: 'String'
   });
   uuid = Type.String({
-    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}$",
-    errorType: "uuid",
-    example: "a8b2c3d4-e5f6-g7h8-i9j0-k1l2m3n4o5p6",
-    title: "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}$',
+    errorType: 'uuid',
+    example: 'a8b2c3d4-e5f6-g7h8-i9j0-k1l2m3n4o5p6',
+    title: 'UUID'
   });
   email = Type.String({
-    pattern: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
-    errorType: "email",
-    example: "a@b.com",
-    title: "Email"
+    pattern: '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$',
+    errorType: 'email',
+    example: 'a@b.com',
+    title: 'Email'
   });
   uri = Type.String({
-    pattern: "^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$",
-    errorType: "uri",
-    example: "https://forklaunch.com",
-    title: "URI"
+    pattern: '^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$',
+    errorType: 'uri',
+    example: 'https://forklaunch.com',
+    title: 'URI'
   });
   number = Type.Transform(
     Type.Union(
       [
         Type.Number(),
-        Type.String({ pattern: "^[0-9]+$" }),
+        Type.String({ pattern: '^[0-9]+$' }),
         Type.Boolean(),
         Type.Null(),
         Type.BigInt(),
         Type.Date()
       ],
       {
-        errorType: "number-like",
+        errorType: 'number-like',
         example: 123,
-        title: "Number"
+        title: 'Number'
       }
     )
-  ).Decode((value) => {
-    if (typeof value !== "number") {
-      const num = Number(value);
-      if (isNaN(num)) {
-        throw new Error("Invalid number");
-      } else {
-        return num;
+  )
+    .Decode((value) => {
+      if (typeof value !== 'number') {
+        const num = Number(value);
+        if (isNaN(num)) {
+          throw new Error('Invalid number');
+        } else {
+          return num;
+        }
       }
-    }
-    return value;
-  }).Encode(Number);
+      return value;
+    })
+    .Encode(Number);
   bigint = Type.Transform(
     Type.Union(
       [
         Type.BigInt(),
         Type.Number(),
-        Type.String({ pattern: "^[0-9]+n?$" }),
+        Type.String({ pattern: '^[0-9]+n?$' }),
         Type.Boolean(),
         Type.Date()
       ],
       {
-        errorType: "BigInt-like",
+        errorType: 'BigInt-like',
         example: 123n,
-        title: "BigInt"
+        title: 'BigInt'
       }
     )
-  ).Decode((value) => {
-    if (typeof value !== "bigint") {
-      try {
-        if (value instanceof Date) {
-          return BigInt(value.getTime());
+  )
+    .Decode((value) => {
+      if (typeof value !== 'bigint') {
+        try {
+          if (value instanceof Date) {
+            return BigInt(value.getTime());
+          }
+          return BigInt(value);
+        } catch {
+          throw new Error('Invalid bigint');
         }
-        return BigInt(value);
-      } catch {
-        throw new Error("Invalid bigint");
       }
-    }
-    return value;
-  }).Encode(BigInt);
+      return value;
+    })
+    .Encode(BigInt);
   boolean = Type.Transform(
     Type.Union(
       [
         Type.Boolean(),
         Type.String({
-          pattern: "^(t|T)(r|R)(u|U)(e|E)$|^(f|F)(a|A)(l|L)(s|S)(e|E)$"
+          pattern: '^(t|T)(r|R)(u|U)(e|E)$|^(f|F)(a|A)(l|L)(s|S)(e|E)$'
         })
       ],
       {
-        errorType: "boolean-like",
+        errorType: 'boolean-like',
         example: true,
-        title: "Boolean"
+        title: 'Boolean'
       }
     )
-  ).Decode((value) => {
-    if (typeof value === "string") {
-      if (value.toLowerCase() === "true") return true;
-      return false;
-    } else {
-      return value;
-    }
-  }).Encode(Boolean);
+  )
+    .Decode((value) => {
+      if (typeof value === 'string') {
+        if (value.toLowerCase() === 'true') return true;
+        return false;
+      } else {
+        return value;
+      }
+    })
+    .Encode(Boolean);
   date = Type.Transform(
     Type.Union(
       [
         Type.String({
-          pattern: "^\\d{4}(-\\d{2}){0,2}(T\\d{2}:\\d{2}(:\\d{2}(\\.\\d{1,3})?)?(Z|([+-]\\d{2}:\\d{2}))?)?$|^\\d{1,2}\\/\\d{1,2}\\/\\d{4}$|^\\d{4}\\/\\d{1,2}\\/\\d{1,2}$|^\\d+$"
+          pattern:
+            '^\\d{4}(-\\d{2}){0,2}(T\\d{2}:\\d{2}(:\\d{2}(\\.\\d{1,3})?)?(Z|([+-]\\d{2}:\\d{2}))?)?$|^\\d{1,2}\\/\\d{1,2}\\/\\d{4}$|^\\d{4}\\/\\d{1,2}\\/\\d{1,2}$|^\\d+$'
         }),
         Type.Number(),
         Type.Date()
       ],
       {
-        errorType: "date",
-        example: "2025-05-16T21:13:04.123Z",
-        title: "Date"
+        errorType: 'date',
+        example: '2025-05-16T21:13:04.123Z',
+        title: 'Date'
       }
     )
-  ).Decode((value) => {
-    if (value === null || typeof value === "boolean") {
-      return /* @__PURE__ */ new Date(value ? 1 : 0);
-    }
-    return new Date(value);
-  }).Encode((value) => new Date(value).toISOString());
+  )
+    .Decode((value) => {
+      if (value === null || typeof value === 'boolean') {
+        return /* @__PURE__ */ new Date(value ? 1 : 0);
+      }
+      return new Date(value);
+    })
+    .Encode((value) => new Date(value).toISOString());
   symbol = Type.Symbol({
-    title: "Symbol"
+    title: 'Symbol'
+  });
+  nullish = Type.Union([Type.Void(), Type.Null(), Type.Undefined()], {
+    errorType: 'nullish',
+    type: 'null',
+    example: 'null',
+    title: 'Nullish'
   });
-  nullish = Type.Union(
-    [Type.Void(), Type.Null(), Type.Undefined()],
-    {
-      errorType: "nullish",
-      type: "null",
-      example: "null",
-      title: "Nullish"
-    }
-  );
   void = Type.Void({
-    type: "null",
-    example: "void",
-    title: "Void"
+    type: 'null',
+    example: 'void',
+    title: 'Void'
   });
   null = Type.Null({
-    type: "null",
-    example: "null",
-    title: "Null"
+    type: 'null',
+    example: 'null',
+    title: 'Null'
   });
   undefined = Type.Undefined({
-    type: "null",
-    example: "undefined",
-    title: "Undefined"
+    type: 'null',
+    example: 'undefined',
+    title: 'Undefined'
   });
   any = Type.Any({
-    type: "object",
-    example: "any",
-    title: "Any"
+    type: 'object',
+    example: 'any',
+    title: 'Any'
   });
   unknown = Type.Unknown({
-    type: "object",
-    example: "unknown",
-    title: "Unknown"
+    type: 'object',
+    example: 'unknown',
+    title: 'Unknown'
   });
   never = Type.Never({
-    type: "null",
-    example: "never",
-    title: "Never"
+    type: 'null',
+    example: 'never',
+    title: 'Never'
   });
   binary = Type.Transform(
     Type.String({
-      errorType: "binary",
-      format: "binary",
-      example: "a base-64 encodable string",
-      title: "Binary"
+      errorType: 'binary',
+      format: 'binary',
+      example: 'a base-64 encodable string',
+      title: 'Binary'
     })
-  ).Decode((value) => new Uint8Array(Buffer.from(value, "base64"))).Encode((value) => {
-    if (value instanceof Buffer) {
-      return String.fromCharCode(...new Uint8Array(value));
-    }
-    return "";
-  });
+  )
+    .Decode((value) => new Uint8Array(Buffer.from(value, 'base64')))
+    .Encode((value) => {
+      if (value instanceof Buffer) {
+        return String.fromCharCode(...new Uint8Array(value));
+      }
+      return '';
+    });
   file = Type.Transform(
     Type.Unsafe({
-      errorType: "binary",
-      format: "binary",
-      example: "a raw buffer or file stream",
-      title: "File"
+      errorType: 'binary',
+      format: 'binary',
+      example: 'a raw buffer or file stream',
+      title: 'File'
     })
-  ).Decode((value) => {
-    return new InMemoryBlob(value);
-  }).Encode((value) => value.content);
+  )
+    .Decode((value) => {
+      return new InMemoryBlob(value);
+    })
+    .Encode((value) => value.content);
   type = () => this.any;
   /**
    * Extracts the error type of a schema for error messages.
@@ -291,7 +305,7 @@ var TypeboxSchemaValidator = class {
    * @returns The type of the schema for error messages.
    */
   errorType(schema) {
-    if (KindGuard.IsSchema(schema) && Object.hasOwn(schema, "errorType")) {
+    if (KindGuard.IsSchema(schema) && Object.hasOwn(schema, 'errorType')) {
       return schema.errorType;
     } else if (KindGuard.IsLiteral(schema)) {
       return schema.const;
@@ -313,7 +327,11 @@ var TypeboxSchemaValidator = class {
    * @returns {TResolve<T>} The resolved schema.
    */
   schemify(schema) {
-    if (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
+    if (
+      typeof schema === 'string' ||
+      typeof schema === 'number' ||
+      typeof schema === 'boolean'
+    ) {
       return Type.Literal(schema);
     }
     if (KindGuard.IsSchema(schema) || schema instanceof TypeCheck) {
@@ -363,7 +381,7 @@ var TypeboxSchemaValidator = class {
       return this.schemify(schema);
     });
     return Type.Union(unionTypes, {
-      errorType: `any of ${unionTypes.map((s) => this.errorType(s)).join(", ")}`,
+      errorType: `any of ${unionTypes.map((s) => this.errorType(s)).join(', ')}`,
       errorSuffix: true
     });
   }
@@ -434,7 +452,12 @@ var TypeboxSchemaValidator = class {
    * @returns {boolean} True if the value is an instance of the schema.
    */
   isInstanceOf(value, type22) {
-    return typeof value === "object" && value != null && Kind in value && value[Kind] === type22[Kind];
+    return (
+      typeof value === 'object' &&
+      value != null &&
+      Kind in value &&
+      value[Kind] === type22[Kind]
+    );
   }
   /**
    * Validate a value against a schema.
@@ -469,7 +492,7 @@ var TypeboxSchemaValidator = class {
       }
     } else {
       const schemified = this.schemify(schema);
-      if (schemified[Kind] === "Unsafe") {
+      if (schemified[Kind] === 'Unsafe') {
         try {
           if (value instanceof Buffer) {
             conversion = new InMemoryBlob(value);
@@ -478,7 +501,7 @@ var TypeboxSchemaValidator = class {
               {
                 type: ValueErrorType.String,
                 schema: schemified,
-                path: "",
+                path: '',
                 message: `Invalid file type: expected Buffer or string, got ${typeof value}`,
                 value,
                 errors: []
@@ -490,8 +513,8 @@ var TypeboxSchemaValidator = class {
             {
               type: ValueErrorType.String,
               schema: schemified,
-              path: "",
-              message: err instanceof Error ? err.message : "Invalid file type",
+              path: '',
+              message: err instanceof Error ? err.message : 'Invalid file type',
               value,
               errors: []
             }
@@ -505,33 +528,38 @@ var TypeboxSchemaValidator = class {
         }
       }
     }
-    return errors != null && errors.length === 0 ? {
-      ok: true,
-      value: conversion
-    } : {
-      ok: false,
-      errors: errors.flatMap((error) => {
-        if (error.type === ValueErrorType.Union && error.schema.errorType.includes("any of")) {
-          return error.errors.flatMap(
-            (e, idx) => Array.from(e).map((e2) => ({
-              path: [
-                `Union Schema Variant ${idx}`,
-                ...error.path.split("/").slice(1),
-                ...e2.path.split("/").slice(1)
-              ],
-              message: e2.message
-            }))
-          );
-        } else {
-          return [
-            {
-              path: error.path.split("/").slice(1),
-              message: error.message
-            }
-          ];
+    return errors != null && errors.length === 0
+      ? {
+          ok: true,
+          value: conversion
         }
-      })
-    };
+      : {
+          ok: false,
+          errors: errors.flatMap((error) => {
+            if (
+              error.type === ValueErrorType.Union &&
+              error.schema.errorType.includes('any of')
+            ) {
+              return error.errors.flatMap((e, idx) =>
+                Array.from(e).map((e2) => ({
+                  path: [
+                    `Union Schema Variant ${idx}`,
+                    ...error.path.split('/').slice(1),
+                    ...e2.path.split('/').slice(1)
+                  ],
+                  message: e2.message
+                }))
+              );
+            } else {
+              return [
+                {
+                  path: error.path.split('/').slice(1),
+                  message: error.message
+                }
+              ];
+            }
+          })
+        };
   }
   /**
    * Convert a schema to an OpenAPI schema object.
@@ -542,11 +570,11 @@ var TypeboxSchemaValidator = class {
     let schemified = this.schemify(schema);
     if (KindGuard.IsDate(schemified)) {
       schemified = Type.String({
-        format: "date-time"
+        format: 'date-time'
       });
     }
     const newSchema = Object.assign({}, schemified);
-    if (Object.hasOwn(newSchema, "properties")) {
+    if (Object.hasOwn(newSchema, 'properties')) {
       if (newSchema.properties) {
         Object.entries({ ...schemified.properties }).forEach(([key, value]) => {
           if (KindGuard.IsSchema(value) && newSchema.properties) {
@@ -555,21 +583,17 @@ var TypeboxSchemaValidator = class {
         });
       }
     }
-    if (Object.hasOwn(newSchema, "items")) {
+    if (Object.hasOwn(newSchema, 'items')) {
       newSchema.items = this.openapi(newSchema.items);
     }
     if (Array.isArray(newSchema.anyOf)) {
-      newSchema.anyOf = newSchema.anyOf.map(
-        (item) => this.openapi(item)
-      );
+      newSchema.anyOf = newSchema.anyOf.map((item) => this.openapi(item));
     }
     if (Array.isArray(newSchema.oneOf)) {
-      newSchema.oneOf = newSchema.oneOf.map(
-        (item) => this.openapi(item)
-      );
+      newSchema.oneOf = newSchema.oneOf.map((item) => this.openapi(item));
     }
-    if ("errorType" in newSchema) {
-      delete newSchema["errorType"];
+    if ('errorType' in newSchema) {
+      delete newSchema['errorType'];
     }
     return newSchema;
   }
@@ -612,51 +636,60 @@ var openapi = StaticSchemaValidator.openapi.bind(StaticSchemaValidator);
 // domain/schemas/typebox/bullMqWorker.schema.ts
 var BullMqWorkerOptionsSchema = {
   queueOptions: type(),
-  backoffType: union([literal("exponential"), literal("fixed")]),
+  backoffType: union([literal('exponential'), literal('fixed')]),
   retries: number,
   interval: number
 };
 
-// ../../../node_modules/.pnpm/@forklaunch+validator@0.10.5/node_modules/@forklaunch/validator/lib/src/zod/index.mjs
-import {
-  z as z2,
-  ZodType
-} from "zod/v3";
+// ../../../node_modules/.pnpm/@forklaunch+validator@0.10.7/node_modules/@forklaunch/validator/lib/src/zod/index.mjs
+import { z as z2, ZodType } from 'zod/v3';
 
 // ../../../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") {
+  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 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;
+var merge = (...objects) =>
+  objects.reduce((result, current) => {
+    if (current === void 0) {
+      return result;
     }
-    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];
+    if (Array.isArray(current)) {
+      throw new TypeError(
+        'Arguments provided to ts-deepmerge must be objects, not arrays.'
+      );
     }
-  });
-  return result;
-}, {});
+    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,
@@ -670,8 +703,8 @@ merge.withOptions = (options, ...objects) => {
   return result;
 };
 
-// ../../../node_modules/.pnpm/@forklaunch+validator@0.10.5/node_modules/@forklaunch/validator/lib/src/zod/index.mjs
-import { z } from "zod/v3";
+// ../../../node_modules/.pnpm/@forklaunch+validator@0.10.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);
@@ -688,89 +721,96 @@ function iterateZodObject({
   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)
-    }),
-    {}
-  );
+  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];
+  return openApiVersion === '3.0' ? type22 : [type22];
 }
-function parseTransformation({
-  zodRef,
-  schemas,
-  useOutput,
-  openApiVersion
-}) {
+function parseTransformation({ zodRef, schemas, useOutput, openApiVersion }) {
   const input = generateSchema(zodRef._def.schema, useOutput, openApiVersion);
-  let output = "undefined";
+  let output = 'undefined';
   if (useOutput && zodRef._def.effect) {
-    const effect = zodRef._def.effect.type === "transform" ? zodRef._def.effect : null;
-    if (effect && "transform" in 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,
+          ['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 {
-      }
+      } catch {}
     }
   }
   const outputType = output;
   return merge(
     {
-      ...zodRef.description ? { description: zodRef.description } : {},
+      ...(zodRef.description ? { description: zodRef.description } : {}),
       ...input,
-      ...["number", "string", "boolean", "null"].includes(output) ? {
-        type: typeFormat(outputType, openApiVersion)
-      } : {}
+      ...(['number', 'string', 'boolean', 'null'].includes(output)
+        ? {
+            type: typeFormat(outputType, openApiVersion)
+          }
+        : {})
     },
     ...schemas
   );
 }
-function parseString({
-  zodRef,
-  schemas,
-  openApiVersion
-}) {
+function parseString({ zodRef, schemas, openApiVersion }) {
   const baseSchema = {
-    type: typeFormat("string", openApiVersion)
+    type: typeFormat('string', openApiVersion)
   };
   const { checks = [] } = zodRef._def;
   checks.forEach((item) => {
     switch (item.kind) {
-      case "email":
-        baseSchema.format = "email";
+      case 'email':
+        baseSchema.format = 'email';
         break;
-      case "uuid":
-        baseSchema.format = "uuid";
+      case 'uuid':
+        baseSchema.format = 'uuid';
         break;
-      case "cuid":
-        baseSchema.format = "cuid";
+      case 'cuid':
+        baseSchema.format = 'cuid';
         break;
-      case "url":
-        baseSchema.format = "uri";
+      case 'url':
+        baseSchema.format = 'uri';
         break;
-      case "datetime":
-        baseSchema.format = "date-time";
+      case 'datetime':
+        baseSchema.format = 'date-time';
         break;
-      case "length":
+      case 'length':
         baseSchema.minLength = item.value;
         baseSchema.maxLength = item.value;
         break;
-      case "max":
+      case 'max':
         baseSchema.maxLength = item.value;
         break;
-      case "min":
+      case 'min':
         baseSchema.minLength = item.value;
         break;
-      case "regex":
+      case 'regex':
         baseSchema.pattern = item.regex.source;
         break;
     }
@@ -781,45 +821,41 @@ function parseString({
     ...schemas
   );
 }
-function parseNumber({
-  zodRef,
-  schemas,
-  openApiVersion
-}) {
+function parseNumber({ zodRef, schemas, openApiVersion }) {
   const baseSchema = {
-    type: typeFormat("number", openApiVersion)
+    type: typeFormat('number', openApiVersion)
   };
   const { checks = [] } = zodRef._def;
   checks.forEach((item) => {
     switch (item.kind) {
-      case "max":
-        if (item.inclusive || openApiVersion === "3.0") {
+      case 'max':
+        if (item.inclusive || openApiVersion === '3.0') {
           baseSchema.maximum = item.value;
         }
         if (!item.inclusive) {
-          if (openApiVersion === "3.0") {
+          if (openApiVersion === '3.0') {
             baseSchema.exclusiveMaximum = true;
           } else {
             baseSchema.exclusiveMaximum = item.value;
           }
         }
         break;
-      case "min":
-        if (item.inclusive || openApiVersion === "3.0") {
+      case 'min':
+        if (item.inclusive || openApiVersion === '3.0') {
           baseSchema.minimum = item.value;
         }
         if (!item.inclusive) {
-          if (openApiVersion === "3.0") {
+          if (openApiVersion === '3.0') {
             baseSchema.exclusiveMinimum = true;
           } else {
             baseSchema.exclusiveMinimum = item.value;
           }
         }
         break;
-      case "int":
-        baseSchema.type = typeFormat("integer", openApiVersion);
+      case 'int':
+        baseSchema.type = typeFormat('integer', openApiVersion);
         break;
-      case "multipleOf":
+      case 'multipleOf':
         baseSchema.multipleOf = item.value;
         break;
     }
@@ -847,26 +883,37 @@ function parseObject({
   openApiVersion
 }) {
   let additionalProperties;
-  if (!(zodRef._def.catchall instanceof z.ZodNever || zodRef._def.catchall?._def.typeName === "ZodNever"))
+  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")
+  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) => {
+  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");
+    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 } : {};
+  const required =
+    requiredProperties.length > 0 ? { required: requiredProperties } : {};
   return merge(
     {
-      type: typeFormat("object", openApiVersion),
+      type: typeFormat('object', openApiVersion),
       properties: iterateZodObject({
         zodRef,
         schemas,
@@ -878,110 +925,83 @@ function parseObject({
       ...additionalProperties,
       ...hideDefinitions
     },
-    zodRef.description ? { description: zodRef.description, hideDefinitions } : {},
+    zodRef.description
+      ? { description: zodRef.description, hideDefinitions }
+      : {},
     ...schemas
   );
 }
-function parseRecord({
-  zodRef,
-  schemas,
-  useOutput,
-  openApiVersion
-}) {
+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)
+      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
-}) {
+function parseBigInt({ zodRef, schemas, openApiVersion }) {
   return merge(
     {
-      type: typeFormat("integer", openApiVersion),
-      format: "int64"
+      type: typeFormat('integer', openApiVersion),
+      format: 'int64'
     },
     zodRef.description ? { description: zodRef.description } : {},
     ...schemas
   );
 }
-function parseBoolean({
-  zodRef,
-  schemas,
-  openApiVersion
-}) {
+function parseBoolean({ zodRef, schemas, openApiVersion }) {
   return merge(
-    { type: typeFormat("boolean", openApiVersion) },
+    { type: typeFormat('boolean', openApiVersion) },
     zodRef.description ? { description: zodRef.description } : {},
     ...schemas
   );
 }
-function parseDate({
-  zodRef,
-  schemas,
-  openApiVersion
-}) {
+function parseDate({ zodRef, schemas, openApiVersion }) {
   return merge(
     {
-      type: typeFormat("string", openApiVersion),
-      format: "date-time"
+      type: typeFormat('string', openApiVersion),
+      format: 'date-time'
     },
     zodRef.description ? { description: zodRef.description } : {},
     ...schemas
   );
 }
-function parseNull({
-  zodRef,
-  schemas,
-  openApiVersion
-}) {
+function parseNull({ zodRef, schemas, openApiVersion }) {
   return merge(
-    openApiVersion === "3.0" ? { type: "null" } : {
-      type: ["string", "null"],
-      enum: ["null"]
-    },
+    openApiVersion === '3.0'
+      ? { type: 'null' }
+      : {
+          type: ['string', 'null'],
+          enum: ['null']
+        },
     zodRef.description ? { description: zodRef.description } : {},
     ...schemas
   );
 }
-function parseOptional({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
+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
-}) {
+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) },
+    openApiVersion === '3.0'
+      ? { nullable: true }
+      : { type: typeFormat('null', openApiVersion) },
     zodRef.description ? { description: zodRef.description } : {},
     ...schemas
   );
 }
-function parseDefault({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
+function parseDefault({ schemas, zodRef, useOutput, openApiVersion }) {
   return merge(
     {
       default: zodRef._def.defaultValue(),
@@ -991,12 +1011,7 @@ function parseDefault({
     ...schemas
   );
 }
-function parseArray({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
+function parseArray({ schemas, zodRef, useOutput, openApiVersion }) {
   const constraints = {};
   if (zodRef._def.exactLength != null) {
     constraints.minItems = zodRef._def.exactLength.value;
@@ -1008,7 +1023,7 @@ function parseArray({
     constraints.maxItems = zodRef._def.maxLength.value;
   return merge(
     {
-      type: typeFormat("array", openApiVersion),
+      type: typeFormat('array', openApiVersion),
       items: generateSchema(zodRef.element, useOutput, openApiVersion),
       ...constraints
     },
@@ -1016,11 +1031,7 @@ function parseArray({
     ...schemas
   );
 }
-function parseLiteral({
-  schemas,
-  zodRef,
-  openApiVersion
-}) {
+function parseLiteral({ schemas, zodRef, openApiVersion }) {
   const type22 = typeof zodRef._def.value;
   return merge(
     {
@@ -1031,11 +1042,7 @@ function parseLiteral({
     ...schemas
   );
 }
-function parseEnum({
-  schemas,
-  zodRef,
-  openApiVersion
-}) {
+function parseEnum({ schemas, zodRef, openApiVersion }) {
   const type22 = typeof Object.values(zodRef._def.values)[0];
   return merge(
     {
@@ -1046,12 +1053,7 @@ function parseEnum({
     ...schemas
   );
 }
-function parseIntersection({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
+function parseIntersection({ schemas, zodRef, useOutput, openApiVersion }) {
   return merge(
     {
       allOf: [
@@ -1063,20 +1065,20 @@ function parseIntersection({
     ...schemas
   );
 }
-function parseUnion({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
+function parseUnion({ schemas, zodRef, useOutput, openApiVersion }) {
   const contents = zodRef._def.options;
-  if (contents.reduce(
-    (prev, content) => prev && content._def.typeName === "ZodLiteral",
-    true
-  )) {
+  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,
+      (prev, content) =>
+        !prev || prev === typeof content._def.value
+          ? typeof content._def.value
+          : null,
       null
     );
     if (type22) {
@@ -1090,12 +1092,15 @@ function parseUnion({
       );
     }
   }
-  const oneOfContents = openApiVersion === "3.0" ? contents.filter((content) => content._def.typeName !== "ZodNull") : contents;
+  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)
+      oneOf: oneOfContents.map((schema) =>
+        generateSchema(schema, useOutput, openApiVersion)
       )
     },
     contentsHasNull ? { nullable: true } : {},
@@ -1114,50 +1119,34 @@ function parseDiscriminatedUnion({
       discriminator: {
         propertyName: zodRef._def.discriminator
       },
-      oneOf: Array.from(
-        zodRef._def.options.values()
-      ).map((schema) => generateSchema(schema, useOutput, openApiVersion))
+      oneOf: Array.from(zodRef._def.options.values()).map((schema) =>
+        generateSchema(schema, useOutput, openApiVersion)
+      )
     },
     zodRef.description ? { description: zodRef.description } : {},
     ...schemas
   );
 }
-function parseNever({
-  zodRef,
-  schemas
-}) {
+function parseNever({ zodRef, schemas }) {
   return merge(
     { readOnly: true },
     zodRef.description ? { description: zodRef.description } : {},
     ...schemas
   );
 }
-function parseBranded({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
+function parseBranded({ schemas, zodRef, useOutput, openApiVersion }) {
   return merge(
     generateSchema(zodRef._def.type, useOutput, openApiVersion),
     ...schemas
   );
 }
-function catchAllParser({
-  zodRef,
-  schemas
-}) {
+function catchAllParser({ zodRef, schemas }) {
   return merge(
     zodRef.description ? { description: zodRef.description } : {},
     ...schemas
   );
 }
-function parsePipeline({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
+function parsePipeline({ schemas, zodRef, useOutput, openApiVersion }) {
   return merge(
     generateSchema(
       useOutput ? zodRef._def.out : zodRef._def.in,
@@ -1167,12 +1156,7 @@ function parsePipeline({
     ...schemas
   );
 }
-function parseReadonly({
-  zodRef,
-  useOutput,
-  schemas,
-  openApiVersion
-}) {
+function parseReadonly({ zodRef, useOutput, schemas, openApiVersion }) {
   return merge(
     generateSchema(zodRef._def.innerType, useOutput, openApiVersion),
     zodRef.description ? { description: zodRef.description } : {},
@@ -1216,10 +1200,10 @@ var workerMap = {
   ZodPipeline: parsePipeline,
   ZodReadonly: parseReadonly
 };
-function generateSchema(zodRef, useOutput = false, openApiVersion = "3.1") {
+function generateSchema(zodRef, useOutput = false, openApiVersion = '3.1') {
   const { metaOpenApi = {} } = zodRef;
   const schemas = [
-    ...Array.isArray(metaOpenApi) ? metaOpenApi : [metaOpenApi]
+    ...(Array.isArray(metaOpenApi) ? metaOpenApi : [metaOpenApi])
   ];
   try {
     const typeName = zodRef._def.typeName;
@@ -1238,155 +1222,173 @@ function generateSchema(zodRef, useOutput = false, openApiVersion = "3.1") {
   }
 }
 function extendZodWithOpenApi(zod, forceOverride = false) {
-  if (!forceOverride && typeof zod.ZodSchema.prototype.openapi !== "undefined") {
+  if (
+    !forceOverride &&
+    typeof zod.ZodSchema.prototype.openapi !== 'undefined'
+  ) {
     return;
   }
-  zod.ZodSchema.prototype.openapi = function(metadata) {
+  zod.ZodSchema.prototype.openapi = function (metadata) {
     return extendApi(this, metadata);
   };
 }
 extendZodWithOpenApi(z2);
 var ZodSchemaValidator = class {
-  _Type = "Zod";
+  _Type = 'Zod';
   _SchemaCatchall;
   _ValidSchemaObject;
   string = z2.string().openapi({
-    title: "String",
-    example: "a string"
+    title: 'String',
+    example: 'a string'
   });
   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"
+    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 = z2.string().email().openapi({
-    title: "Email",
-    format: "email",
-    pattern: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
-    example: "a@b.com"
+    title: 'Email',
+    format: 'email',
+    pattern: '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$',
+    example: 'a@b.com'
   });
   uri = z2.string().url().openapi({
-    title: "URI",
-    format: "uri",
-    pattern: "^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$",
-    example: "https://forklaunch.com"
+    title: 'URI',
+    format: 'uri',
+    pattern: '^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$',
+    example: 'https://forklaunch.com'
   });
-  number = z2.preprocess((value) => {
-    try {
-      return Number(value);
-    } catch {
-      return value;
-    }
-  }, z2.number()).openapi({
-    title: "Number",
-    example: 123
-  });
-  bigint = z2.preprocess((value) => {
-    try {
-      if (value instanceof Date) {
-        return BigInt(value.getTime());
+  number = z2
+    .preprocess((value) => {
+      try {
+        return Number(value);
+      } catch {
+        return value;
       }
-      switch (typeof value) {
-        case "number":
-        case "string":
-          return BigInt(value);
-        case "boolean":
-          return BigInt(value ? 1 : 0);
-        default:
-          return value;
+    }, z2.number())
+    .openapi({
+      title: 'Number',
+      example: 123
+    });
+  bigint = z2
+    .preprocess((value) => {
+      try {
+        if (value instanceof Date) {
+          return BigInt(value.getTime());
+        }
+        switch (typeof value) {
+          case 'number':
+          case 'string':
+            return BigInt(value);
+          case 'boolean':
+            return BigInt(value ? 1 : 0);
+          default:
+            return value;
+        }
+      } catch {
+        return value;
       }
-    } catch {
-      return value;
-    }
-  }, z2.bigint()).openapi({
-    title: "BigInt",
-    type: "integer",
-    format: "int64",
-    example: 123n
-  });
-  boolean = z2.preprocess((val) => {
-    if (typeof val === "string") {
-      if (val.toLowerCase() === "true") return true;
-      if (val.toLowerCase() === "false") return false;
-    }
-    return val;
-  }, z2.boolean()).openapi({
-    title: "Boolean",
-    example: true
-  });
-  date = z2.preprocess((value) => {
-    try {
-      switch (typeof value) {
-        case "string":
-          return new Date(value);
-        case "number":
-          return new Date(value);
-        default:
-          return value;
+    }, z2.bigint())
+    .openapi({
+      title: 'BigInt',
+      type: 'integer',
+      format: 'int64',
+      example: 123n
+    });
+  boolean = z2
+    .preprocess((val) => {
+      if (typeof val === 'string') {
+        if (val.toLowerCase() === 'true') return true;
+        if (val.toLowerCase() === 'false') return false;
       }
-    } catch {
-      return value;
-    }
-  }, z2.date()).openapi({
-    title: "Date",
-    type: "string",
-    format: "date-time",
-    example: "2025-05-16T21:13:04.123Z"
-  });
+      return val;
+    }, z2.boolean())
+    .openapi({
+      title: 'Boolean',
+      example: true
+    });
+  date = z2
+    .preprocess((value) => {
+      try {
+        switch (typeof value) {
+          case 'string':
+            return new Date(value);
+          case 'number':
+            return new Date(value);
+          default:
+            return value;
+        }
+      } catch {
+        return value;
+      }
+    }, z2.date())
+    .openapi({
+      title: 'Date',
+      type: 'string',
+      format: 'date-time',
+      example: '2025-05-16T21:13:04.123Z'
+    });
   symbol = z2.symbol().openapi({
-    title: "Symbol",
-    example: Symbol("symbol")
+    title: 'Symbol',
+    example: Symbol('symbol')
   });
   nullish = z2.union([z2.void(), z2.null(), z2.undefined()]).openapi({
-    title: "Nullish",
-    type: "null",
+    title: 'Nullish',
+    type: 'null',
     example: null
   });
   void = z2.void().openapi({
-    title: "Void",
-    type: "null",
+    title: 'Void',
+    type: 'null',
     example: void 0
   });
   null = z2.null().openapi({
-    title: "Null",
-    type: "null",
+    title: 'Null',
+    type: 'null',
     example: null
   });
   undefined = z2.undefined().openapi({
-    title: "Undefined",
-    type: "null",
+    title: 'Undefined',
+    type: 'null',
     example: void 0
   });
   any = z2.any().openapi({
-    title: "Any",
-    type: "object",
-    example: "any"
+    title: 'Any',
+    type: 'object',
+    example: 'any'
   });
   unknown = z2.unknown().openapi({
-    title: "Unknown",
-    type: "object",
-    example: "unknown"
+    title: 'Unknown',
+    type: 'object',
+    example: 'unknown'
   });
   never = z2.never().openapi({
-    title: "Never",
-    type: "null",
-    example: "never"
-  });
-  binary = z2.string().transform((val) => new Uint8Array(Buffer.from(val, "base64"))).openapi({
-    title: "Binary",
-    type: "string",
-    format: "binary",
-    example: "a base-64 encodable string"
-  });
-  file = z2.instanceof(Buffer).transform((val) => {
-    return new Blob([val]);
-  }).openapi({
-    title: "File",
-    type: "string",
-    format: "binary",
-    example: "a base-64 encodable blob or file"
+    title: 'Never',
+    type: 'null',
+    example: 'never'
   });
+  binary = z2
+    .string()
+    .transform((val) => new Uint8Array(Buffer.from(val, 'base64')))
+    .openapi({
+      title: 'Binary',
+      type: 'string',
+      format: 'binary',
+      example: 'a base-64 encodable string'
+    });
+  file = z2
+    .instanceof(Buffer)
+    .transform((val) => {
+      return new Blob([val]);
+    })
+    .openapi({
+      title: 'File',
+      type: 'string',
+      format: 'binary',
+      example: 'a base-64 encodable blob or file'
+    });
   type = () => this.any;
   /**
    * Compiles schema if this exists, for optimal performance.
@@ -1403,7 +1405,11 @@ var ZodSchemaValidator = class {
    * @returns {ZodResolve<T>} The resolved schema.
    */
   schemify(schema) {
-    if (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
+    if (
+      typeof schema === 'string' ||
+      typeof schema === 'number' ||
+      typeof schema === 'boolean'
+    ) {
       return z2.literal(schema);
     }
     if (schema instanceof ZodType) {
@@ -1444,9 +1450,7 @@ var ZodSchemaValidator = class {
    */
   union(schemas) {
     const resolvedSchemas = schemas.map((schema) => this.schemify(schema));
-    return z2.union(
-      resolvedSchemas
-    );
+    return z2.union(resolvedSchemas);
   }
   /**
    * Create a literal schema.
@@ -1462,9 +1466,7 @@ var ZodSchemaValidator = class {
    * @returns {ZodUnion<UnionZodResolve<[T, T, ...T[]]>>} The enum schema.
    */
   enum_(schemaEnum) {
-    return this.union(
-      Object.values(schemaEnum)
-    );
+    return this.union(Object.values(schemaEnum));
   }
   /**
    * Create a function schema.
@@ -1533,31 +1535,33 @@ var ZodSchemaValidator = class {
   parse(schema, value) {
     const resolvedSchema = this.schemify(schema);
     const result = resolvedSchema.safeParse(value);
-    return result.success ? { ok: true, value: result.data } : {
-      ok: false,
-      errors: result.error.errors.flatMap((error) => {
-        switch (error.code) {
-          case "invalid_union":
-            return error.unionErrors.flatMap(
-              (unionError, idx) => unionError.errors.map((e) => ({
-                path: [
-                  `Union Schema Variant ${idx}`,
-                  ...error.path.map((p) => p.toString()),
-                  ...e.path.map((p) => p.toString())
-                ],
-                message: e.message
-              }))
-            );
-          default:
-            return [
-              {
-                path: error.path.map((p) => p.toString()),
-                message: error.message
-              }
-            ];
-        }
-      })
-    };
+    return result.success
+      ? { ok: true, value: result.data }
+      : {
+          ok: false,
+          errors: result.error.errors.flatMap((error) => {
+            switch (error.code) {
+              case 'invalid_union':
+                return error.unionErrors.flatMap((unionError, idx) =>
+                  unionError.errors.map((e) => ({
+                    path: [
+                      `Union Schema Variant ${idx}`,
+                      ...error.path.map((p) => p.toString()),
+                      ...e.path.map((p) => p.toString())
+                    ],
+                    message: e.message
+                  }))
+                );
+              default:
+                return [
+                  {
+                    path: error.path.map((p) => p.toString()),
+                    message: error.message
+                  }
+                ];
+            }
+          })
+        };
   }
   /**
    * Convert a schema to an OpenAPI schema object.
@@ -1606,7 +1610,7 @@ var openapi2 = StaticSchemaValidator2.openapi.bind(StaticSchemaValidator2);
 // domain/schemas/zod/bullMqWorker.schema.ts
 var BullMqWorkerOptionsSchema2 = {
   queueOptions: type2(),
-  backoffType: union2([literal2("exponential"), literal2("fixed")]),
+  backoffType: union2([literal2('exponential'), literal2('fixed')]),
   retries: number2,
   interval: number2
 };
@@ -1616,6 +1620,4 @@ var BullMqWorkerSchemas = serviceSchemaResolver(
   () => BullMqWorkerOptionsSchema,
   () => BullMqWorkerOptionsSchema2
 );
-export {
-  BullMqWorkerSchemas
-};
+export { BullMqWorkerSchemas };