@forklaunch/implementation-worker-redis 0.2.2 → 0.3.0

package/lib/schemas/index.js

@@ -1 +1,1371 @@
-export * from './redisWorker.schema';
+"use strict";
+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 __commonJS = (cb, mod) => function __require() {
+  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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  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 });
+  }
+  return to;
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), 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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__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;
+    };
+    exports2.default = merge;
+  }
+});
+
+// ../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.4.0_zod@3.25.62/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.4.0_zod@3.25.62/node_modules/@anatine/zod-openapi/src/lib/zod-openapi.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.generateSchema = exports2.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;
+    }
+    exports2.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 });
+      }
+    }
+    exports2.generateSchema = generateSchema2;
+  }
+});
+
+// ../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.4.0_zod@3.25.62/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.4.0_zod@3.25.62/node_modules/@anatine/zod-openapi/src/lib/zod-extensions.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.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);
+      };
+    }
+    exports2.extendZodWithOpenApi = extendZodWithOpenApi2;
+  }
+});
+
+// ../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.4.0_zod@3.25.62/node_modules/@anatine/zod-openapi/src/index.js
+var require_src = __commonJS({
+  "../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.4.0_zod@3.25.62/node_modules/@anatine/zod-openapi/src/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__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 = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_zod_openapi(), exports2);
+    __exportStar(require_zod_extensions(), exports2);
+  }
+});
+
+// schemas/index.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  RedisWorkerSchemas: () => RedisWorkerSchemas
+});
+module.exports = __toCommonJS(schemas_exports);
+
+// schemas/redisWorker.schema.ts
+var import_mappers = require("@forklaunch/core/mappers");
+
+// ../../../node_modules/.pnpm/@forklaunch+common@0.3.11/node_modules/@forklaunch/common/lib/index.mjs
+var InMemoryFile = class extends File {
+  constructor(content, name, {
+    type: type3,
+    endings,
+    lastModified
+  }) {
+    super([Buffer.from(content)], name, {
+      type: type3,
+      endings,
+      lastModified
+    });
+    this.content = content;
+  }
+};
+
+// ../../../node_modules/.pnpm/@forklaunch+validator@0.6.12_openapi3-ts@4.4.0/node_modules/@forklaunch/validator/lib/src/typebox/index.mjs
+var import_typebox = require("@sinclair/typebox");
+var import_compiler = require("@sinclair/typebox/compiler");
+var import_errors = require("@sinclair/typebox/errors");
+var import_value = require("@sinclair/typebox/value");
+import_typebox.FormatRegistry.Set("binary", (value) => typeof value === "string");
+(0, import_errors.SetErrorFunction)((params) => {
+  switch (params.errorType) {
+    case import_errors.ValueErrorType.Union:
+    case import_errors.ValueErrorType.Array:
+    case import_errors.ValueErrorType.String:
+    case import_errors.ValueErrorType.Number:
+      return params.schema.errorType ? `Expected ${params.schema.errorType} value${params.schema.errorSuffix ? "s" : ""}` : (0, import_errors.DefaultErrorFunction)(params);
+    default:
+      return (0, import_errors.DefaultErrorFunction)(params);
+  }
+});
+var TypeboxSchemaValidator = class {
+  _Type = "TypeBox";
+  _SchemaCatchall;
+  _ValidSchemaObject;
+  string = import_typebox.Type.String({
+    example: "a string",
+    title: "String"
+  });
+  uuid = import_typebox.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"
+  });
+  email = import_typebox.Type.String({
+    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])+)])`,
+    errorType: "email",
+    example: "a@b.com",
+    title: "Email"
+  });
+  uri = import_typebox.Type.String({
+    pattern: "^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$",
+    errorType: "uri",
+    example: "https://forklaunch.com",
+    title: "URI"
+  });
+  number = import_typebox.Type.Transform(
+    import_typebox.Type.Union(
+      [
+        import_typebox.Type.Number(),
+        import_typebox.Type.String({ pattern: "^[0-9]+$" }),
+        import_typebox.Type.Boolean(),
+        import_typebox.Type.Null(),
+        import_typebox.Type.BigInt(),
+        import_typebox.Type.Date()
+      ],
+      {
+        errorType: "number-like",
+        example: 123,
+        title: "Number"
+      }
+    )
+  ).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);
+  bigint = import_typebox.Type.Transform(
+    import_typebox.Type.Union(
+      [
+        import_typebox.Type.BigInt(),
+        import_typebox.Type.Number(),
+        import_typebox.Type.String({ pattern: "^[0-9]+n?$" }),
+        import_typebox.Type.Boolean(),
+        import_typebox.Type.Date()
+      ],
+      {
+        errorType: "BigInt-like",
+        example: 123n,
+        title: "BigInt"
+      }
+    )
+  ).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 value;
+  }).Encode(BigInt);
+  boolean = import_typebox.Type.Transform(
+    import_typebox.Type.Union(
+      [
+        import_typebox.Type.Boolean(),
+        import_typebox.Type.String({
+          pattern: "^(t|T)(r|R)(u|U)(e|E)$|^(f|F)(a|A)(l|L)(s|S)(e|E)$"
+        })
+      ],
+      {
+        errorType: "boolean-like",
+        example: true,
+        title: "Boolean"
+      }
+    )
+  ).Decode((value) => {
+    if (typeof value === "string") {
+      if (value.toLowerCase() === "true") return true;
+      return false;
+    } else {
+      return value;
+    }
+  }).Encode(Boolean);
+  date = import_typebox.Type.Transform(
+    import_typebox.Type.Union(
+      [
+        import_typebox.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+$"
+        }),
+        import_typebox.Type.Number(),
+        import_typebox.Type.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());
+  symbol = import_typebox.Type.Symbol({
+    title: "Symbol"
+  });
+  nullish = import_typebox.Type.Union(
+    [import_typebox.Type.Void(), import_typebox.Type.Null(), import_typebox.Type.Undefined()],
+    {
+      errorType: "nullish",
+      type: "null",
+      example: "null",
+      title: "Nullish"
+    }
+  );
+  void = import_typebox.Type.Void({
+    type: "null",
+    example: "void",
+    title: "Void"
+  });
+  null = import_typebox.Type.Null({
+    type: "null",
+    example: "null",
+    title: "Null"
+  });
+  undefined = import_typebox.Type.Undefined({
+    type: "null",
+    example: "undefined",
+    title: "Undefined"
+  });
+  any = import_typebox.Type.Any({
+    type: "object",
+    example: "any",
+    title: "Any"
+  });
+  unknown = import_typebox.Type.Unknown({
+    type: "object",
+    example: "unknown",
+    title: "Unknown"
+  });
+  never = import_typebox.Type.Never({
+    type: "null",
+    example: "never",
+    title: "Never"
+  });
+  binary = import_typebox.Type.Transform(
+    import_typebox.Type.String({
+      errorType: "binary",
+      format: "binary",
+      example: "a utf-8 encodable string",
+      title: "Binary"
+    })
+  ).Decode((value) => new TextEncoder().encode(value)).Encode((value) => {
+    if (value instanceof ArrayBuffer) {
+      return String.fromCharCode(...new Uint8Array(value));
+    }
+    return "";
+  });
+  file = import_typebox.Type.Transform(
+    import_typebox.Type.String({
+      errorType: "binary",
+      format: "binary",
+      example: "a utf-8 encodable string",
+      title: "File"
+    })
+  ).Decode(
+    (value) => (name, type22) => new InMemoryFile(value, name, { type: type22 })
+  ).Encode((value) => value("name", "type").content);
+  type = () => this.any;
+  /**
+   * Extracts the error type of a schema for error messages.
+   *
+   * @param {TCatchall} schema - A schema that contains some type information.
+   * @returns The type of the schema for error messages.
+   */
+  errorType(schema) {
+    if (import_typebox.KindGuard.IsSchema(schema) && Object.hasOwn(schema, "errorType")) {
+      return schema.errorType;
+    } else if (import_typebox.KindGuard.IsLiteral(schema)) {
+      return schema.const;
+    }
+    return schema[import_typebox.Kind].toLowerCase();
+  }
+  /**
+   * Compiles schema if this exists, for optimal performance.
+   *
+   * @param {TObject<TProperties>} schema - The schema to compile.
+   * @returns {TypeCheck<T>} - The compiled schema.
+   */
+  compile(schema) {
+    return import_compiler.TypeCompiler.Compile(schema);
+  }
+  /**
+   * Convert a schema to a TypeBox schema.
+   * @param {TIdiomaticSchema} schema - The schema to convert.
+   * @returns {TResolve<T>} The resolved schema.
+   */
+  schemify(schema) {
+    if (import_typebox.KindGuard.IsSchema(schema) || schema instanceof import_compiler.TypeCheck) {
+      return schema;
+    }
+    if (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
+      return import_typebox.Type.Literal(schema);
+    }
+    const newSchema = {};
+    Object.getOwnPropertyNames(schema).forEach((key) => {
+      if (import_typebox.KindGuard.IsSchema(schema[key])) {
+        newSchema[key] = schema[key];
+      } else {
+        const schemified = this.schemify(schema[key]);
+        newSchema[key] = schemified;
+      }
+    });
+    return import_typebox.Type.Object(newSchema);
+  }
+  /**
+   * Make a schema optional.
+   * @param {TIdiomaticSchema} schema - The schema to make optional.
+   * @returns {TOptional<TResolve<T>>} The optional schema.
+   */
+  optional(schema) {
+    const schemified = this.schemify(schema);
+    return import_typebox.Type.Optional(schemified);
+  }
+  /**
+   * Create an array schema.
+   * @param {TIdiomaticSchema} schema - The schema to use for array items.
+   * @returns {TArray<TResolve<T>>} The array schema.
+   */
+  array(schema) {
+    const schemified = this.schemify(schema);
+    return import_typebox.Type.Array(schemified, {
+      errorType: `array of ${this.errorType(schemified)}`
+    });
+  }
+  /**
+   * Create a union schema.
+   * @param {TUnionTupleContainer} schemas - The schemas to union.
+   * @returns {TUnion<UnionTupleTResolve<T>>} The union schema.
+   *
+   * WARNING: If "nullish" or TUndefined is included in the union, the key will still be expected.
+   * This is a limitation of TypeBox. Consider using "optional" instead.
+   */
+  union(schemas) {
+    const unionTypes = schemas.map((schema) => {
+      return this.schemify(schema);
+    });
+    return import_typebox.Type.Union(unionTypes, {
+      errorType: `any of ${unionTypes.map((s) => this.errorType(s)).join(", ")}`,
+      errorSuffix: true
+    });
+  }
+  /**
+   * Create a literal schema.
+   * @param {LiteralSchema} value - The literal value.
+   * @returns {TLiteral<T>} The literal schema.
+   */
+  literal(value) {
+    return import_typebox.Type.Literal(value, {
+      errorType: value
+    });
+  }
+  /**
+   * Create an enum schema.
+   * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
+   * @returns {TUnion<UnionTupleTResolve<T[]>>} The enum schema.
+   */
+  enum_(schemaEnum) {
+    return this.union(
+      Object.values(schemaEnum).map((value) => this.literal(value))
+    );
+  }
+  /**
+   * Create a function schema.
+   * @param {TSchema[]} args - The arguments of the function.
+   * @param {TAny} returnType - The return type of the function.
+   * @returns {TFunction<Args, ReturnType>} The function schema.
+   */
+  function_(args, returnType) {
+    const schemaArgs = args.map((schema) => {
+      return this.schemify(schema);
+    });
+    const schemaReturnType = this.schemify(returnType);
+    return import_typebox.Type.Function(schemaArgs, schemaReturnType);
+  }
+  /**
+   * Create a record schema.
+   * @param {TIdiomaticSchema} key - The key schema.
+   * @param {TIdiomaticSchema} value - The value schema.
+   * @returns {TRecord<TResolve<Key>, TResolve<Value>>} The record schema.
+   */
+  record(key, value) {
+    const keySchema = this.schemify(key);
+    const valueSchema = this.schemify(value);
+    return import_typebox.Type.Record(keySchema, valueSchema);
+  }
+  /**
+   * Create a promise schema.
+   * @param {TIdiomaticSchema} schema - The schema to use for the promise.
+   * @returns {TPromise<TResolve<T>>} The promise schema.
+   */
+  promise(schema) {
+    return import_typebox.Type.Promise(this.schemify(schema));
+  }
+  /**
+   * Check if a value is a TypeBox object schema.
+   * @param {unknown} value - The value to check.
+   * @returns {boolean} True if the value is a TypeBox object schema.
+   */
+  isSchema(value) {
+    return import_typebox.KindGuard.IsSchema(value);
+  }
+  /**
+   * Check if a value is an instance of a TypeBox schema.
+   * @param {object} value - The value to check.
+   * @param {TCatchall} type - The schema to check against.
+   * @returns {boolean} True if the value is an instance of the schema.
+   */
+  isInstanceOf(value, type22) {
+    return typeof value === "object" && value != null && import_typebox.Kind in value && value[import_typebox.Kind] === type22[import_typebox.Kind];
+  }
+  /**
+   * Validate a value against a schema.
+   *
+   * @param {TSchema} schema - The schema to validate against.
+   * @param {unknown} value - The value to validate.
+   * @returns {boolean} True if valid, otherwise false.
+   */
+  validate(schema, value) {
+    if (schema instanceof import_compiler.TypeCheck) {
+      return schema.Check(value);
+    } else {
+      const schemified = this.schemify(schema);
+      return import_value.Value.Check(schemified, value);
+    }
+  }
+  /**
+   * Parse a value against a schema.
+   *
+   * @param {TSchema} schema - The schema to validate against.
+   * @param {unknown} value - The value to validate.
+   * @returns {ParseResult<TResolve<T>>} The parsing result.
+   */
+  parse(schema, value) {
+    let errors = [];
+    let conversion;
+    if (schema instanceof import_compiler.TypeCheck) {
+      if (schema.Check(value)) {
+        conversion = schema.Decode(value);
+      } else {
+        errors = Array.from(schema.Errors(value));
+      }
+    } else {
+      const schemified = this.schemify(schema);
+      if (import_value.Value.Check(schemified, value)) {
+        conversion = import_value.Value.Decode(schemified, value);
+      } else {
+        errors = Array.from(import_value.Value.Errors(schemified, value));
+      }
+    }
+    return errors != null && errors.length === 0 ? {
+      ok: true,
+      value: conversion
+    } : {
+      ok: false,
+      errors: errors.flatMap((error) => {
+        if (error.type === import_errors.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.
+   * @param {TIdiomaticSchema | TCatchall} schema - The schema to convert.
+   * @returns {SchemaObject} The OpenAPI schema object.
+   */
+  openapi(schema) {
+    let schemified = this.schemify(schema);
+    if (import_typebox.KindGuard.IsDate(schemified)) {
+      schemified = import_typebox.Type.String({
+        format: "date-time"
+      });
+    }
+    const newSchema = Object.assign({}, schemified);
+    if (Object.hasOwn(newSchema, "properties")) {
+      if (newSchema.properties) {
+        Object.entries({ ...schemified.properties }).forEach(([key, value]) => {
+          if (import_typebox.KindGuard.IsSchema(value) && newSchema.properties) {
+            newSchema.properties[key] = this.openapi(value);
+          }
+        });
+      }
+    }
+    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)
+      );
+    }
+    if (Array.isArray(newSchema.oneOf)) {
+      newSchema.oneOf = newSchema.oneOf.map(
+        (item) => this.openapi(item)
+      );
+    }
+    if ("errorType" in newSchema) {
+      delete newSchema["errorType"];
+    }
+    return newSchema;
+  }
+};
+var SchemaValidator = () => new TypeboxSchemaValidator();
+var StaticSchemaValidator = SchemaValidator();
+var string = StaticSchemaValidator.string;
+var uuid = StaticSchemaValidator.uuid;
+var uri = StaticSchemaValidator.uri;
+var email = StaticSchemaValidator.email;
+var number = StaticSchemaValidator.number;
+var bigint = StaticSchemaValidator.bigint;
+var boolean = StaticSchemaValidator.boolean;
+var date = StaticSchemaValidator.date;
+var symbol = StaticSchemaValidator.symbol;
+var nullish = StaticSchemaValidator.nullish;
+var void_ = StaticSchemaValidator.void;
+var null_ = StaticSchemaValidator.null;
+var undefined_ = StaticSchemaValidator.undefined;
+var any = StaticSchemaValidator.any;
+var unknown = StaticSchemaValidator.unknown;
+var never = StaticSchemaValidator.never;
+var binary = StaticSchemaValidator.binary;
+var file = StaticSchemaValidator.file;
+var type = StaticSchemaValidator.type;
+var schemify = StaticSchemaValidator.schemify.bind(StaticSchemaValidator);
+var optional = StaticSchemaValidator.optional.bind(StaticSchemaValidator);
+var array = StaticSchemaValidator.array.bind(StaticSchemaValidator);
+var union = StaticSchemaValidator.union.bind(StaticSchemaValidator);
+var literal = StaticSchemaValidator.literal.bind(StaticSchemaValidator);
+var enum_ = StaticSchemaValidator.enum_.bind(StaticSchemaValidator);
+var function_ = StaticSchemaValidator.function_.bind(StaticSchemaValidator);
+var record = StaticSchemaValidator.record.bind(StaticSchemaValidator);
+var promise = StaticSchemaValidator.promise.bind(StaticSchemaValidator);
+var isSchema = StaticSchemaValidator.isSchema.bind(StaticSchemaValidator);
+var validate = StaticSchemaValidator.validate.bind(StaticSchemaValidator);
+var parse = StaticSchemaValidator.parse.bind(StaticSchemaValidator);
+var openapi = StaticSchemaValidator.openapi.bind(StaticSchemaValidator);
+
+// schemas/typebox/redisWorker.schema.ts
+var RedisWorkerOptionsSchema = {
+  pageSize: number,
+  retries: number,
+  interval: number
+};
+
+// ../../../node_modules/.pnpm/@forklaunch+validator@0.6.12_openapi3-ts@4.4.0/node_modules/@forklaunch/validator/lib/src/zod/index.mjs
+var import_zod_openapi = __toESM(require_src(), 1);
+var import_zod = require("zod");
+(0, import_zod_openapi.extendZodWithOpenApi)(import_zod.z);
+var ZodSchemaValidator = class {
+  _Type = "Zod";
+  _SchemaCatchall;
+  _ValidSchemaObject;
+  string = import_zod.z.string().openapi({
+    title: "String",
+    example: "a string"
+  });
+  uuid = import_zod.z.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 = import_zod.z.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 = import_zod.z.string().url().openapi({
+    title: "URI",
+    format: "uri",
+    pattern: "^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$",
+    example: "https://forklaunch.com"
+  });
+  number = import_zod.z.preprocess((value) => {
+    try {
+      return Number(value);
+    } catch {
+      return value;
+    }
+  }, import_zod.z.number()).openapi({
+    title: "Number",
+    example: 123
+  });
+  bigint = import_zod.z.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;
+    }
+  }, import_zod.z.bigint()).openapi({
+    title: "BigInt",
+    type: "integer",
+    format: "int64",
+    example: 123n
+  });
+  boolean = import_zod.z.preprocess((val) => {
+    if (typeof val === "string") {
+      if (val.toLowerCase() === "true") return true;
+      if (val.toLowerCase() === "false") return false;
+    }
+    return val;
+  }, import_zod.z.boolean()).openapi({
+    title: "Boolean",
+    example: true
+  });
+  date = import_zod.z.preprocess((value) => {
+    try {
+      switch (typeof value) {
+        case "string":
+          return new Date(value);
+        case "number":
+          return new Date(value);
+        default:
+          return value;
+      }
+    } catch {
+      return value;
+    }
+  }, import_zod.z.date()).openapi({
+    title: "Date",
+    type: "string",
+    format: "date-time",
+    example: "2025-05-16T21:13:04.123Z"
+  });
+  symbol = import_zod.z.symbol().openapi({
+    title: "Symbol",
+    example: Symbol("symbol")
+  });
+  nullish = import_zod.z.union([import_zod.z.void(), import_zod.z.null(), import_zod.z.undefined()]).openapi({
+    title: "Nullish",
+    type: "null",
+    example: null
+  });
+  void = import_zod.z.void().openapi({
+    title: "Void",
+    type: "null",
+    example: void 0
+  });
+  null = import_zod.z.null().openapi({
+    title: "Null",
+    type: "null",
+    example: null
+  });
+  undefined = import_zod.z.undefined().openapi({
+    title: "Undefined",
+    type: "null",
+    example: void 0
+  });
+  any = import_zod.z.any().openapi({
+    title: "Any",
+    type: "object",
+    example: "any"
+  });
+  unknown = import_zod.z.unknown().openapi({
+    title: "Unknown",
+    type: "object",
+    example: "unknown"
+  });
+  never = import_zod.z.never().openapi({
+    title: "Never",
+    type: "null",
+    example: "never"
+  });
+  binary = import_zod.z.string().transform((v) => new TextEncoder().encode(v)).openapi({
+    title: "Binary",
+    type: "string",
+    format: "binary",
+    example: "a utf-8 encodable string"
+  });
+  file = import_zod.z.string().transform((val) => {
+    return (name, type22) => new File([val], name, {
+      type: type22,
+      lastModified: Date.now()
+    });
+  }).openapi({
+    title: "File",
+    type: "string",
+    format: "binary",
+    example: "a utf-8 encodable string"
+  });
+  type = () => this.any;
+  /**
+   * Compiles schema if this exists, for optimal performance.
+   *
+   * @param {ZodObject<ZodRawShape>} schema - The schema to compile.
+   * @returns {ZodResolve<T>} - The compiled schema.
+   */
+  compile(schema) {
+    return schema;
+  }
+  /**
+   * Convert a schema to a Zod schema.
+   * @param {ZodIdiomaticSchema} schema - The schema to convert.
+   * @returns {ZodResolve<T>} The resolved schema.
+   */
+  schemify(schema) {
+    if (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
+      return import_zod.z.literal(schema);
+    }
+    if (schema instanceof import_zod.ZodType) {
+      return schema;
+    }
+    const newSchema = {};
+    Object.getOwnPropertyNames(schema).forEach((key) => {
+      if (schema[key] instanceof import_zod.ZodType) {
+        newSchema[key] = schema[key];
+      } else {
+        newSchema[key] = this.schemify(schema[key]);
+      }
+    });
+    return import_zod.z.object(newSchema);
+  }
+  /**
+   * Make a schema optional.
+   * @param {ZodIdiomaticSchema} schema - The schema to make optional.
+   * @returns {ZodOptional<ZodResolve<T>>} The optional schema.
+   */
+  optional(schema) {
+    const resolvedSchema = this.schemify(schema);
+    return resolvedSchema.optional();
+  }
+  /**
+   * Create an array schema.
+   * @param {ZodIdiomaticSchema} schema - The schema to use for array items.
+   * @returns {ZodArray<ZodResolve<T>>} The array schema.
+   */
+  array(schema) {
+    const resolvedSchema = this.schemify(schema);
+    return resolvedSchema.array();
+  }
+  /**
+   * Create a union schema.
+   * @param {ZodUnionContainer} schemas - The schemas to union.
+   * @returns {ZodUnion<UnionZodResolve<T>>} The union schema.
+   */
+  union(schemas) {
+    const resolvedSchemas = schemas.map((schema) => this.schemify(schema));
+    return import_zod.z.union(
+      resolvedSchemas
+    );
+  }
+  /**
+   * Create a literal schema.
+   * @param {LiteralSchema} value - The literal value.
+   * @returns {ZodLiteral<ZodResolve<T>>} The literal schema.
+   */
+  literal(value) {
+    return import_zod.z.literal(value);
+  }
+  /**
+   * Create an enum schema.
+   * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
+   * @returns {ZodUnion<UnionZodResolve<[T, T, ...T[]]>>} The enum schema.
+   */
+  enum_(schemaEnum) {
+    return this.union(
+      Object.values(schemaEnum)
+    );
+  }
+  /**
+   * Create a function schema.
+   * @param {ZodTuple} args - The arguments of the function.
+   * @param {ZodAny} returnType - The return type of the function.
+   * @returns {ZodFunction<Args, ReturnType>} The function schema.
+   */
+  function_(args, returnType) {
+    const schemaArgs = args.map((schema) => this.schemify(schema));
+    const schemaReturnType = this.schemify(returnType);
+    return import_zod.z.function(import_zod.z.tuple(schemaArgs), schemaReturnType);
+  }
+  /**
+   * Create a record schema.
+   * @param {ZodIdiomaticSchema} key - The key schema.
+   * @param {ZodIdiomaticSchema} value - The value schema.
+   * @returns {ZodRecord<ZodResolve<Key>, ZodResolve<Value>>} The record schema.
+   */
+  record(key, value) {
+    const keySchema = this.schemify(key);
+    const valueSchema = this.schemify(value);
+    return import_zod.z.record(keySchema, valueSchema);
+  }
+  /**
+   * Create a promise schema.
+   * @param {ZodIdiomaticSchema} schema - The schema to use for the promise.
+   * @returns {ZodPromise<ZodResolve<T>>} The promise schema.
+   */
+  promise(schema) {
+    return import_zod.z.promise(this.schemify(schema));
+  }
+  /**
+   * Checks if a value is a Zod schema.
+   * @param {unknown} value - The value to check.
+   * @returns {boolean} True if the value is a Zod schema.
+   */
+  isSchema(value) {
+    return value instanceof import_zod.ZodType;
+  }
+  /**
+   * Checks if a value is an instance of a Zod schema.
+   * @param {object} value - The value to check.
+   * @param {ZodType} type - The schema to check against.
+   * @returns {boolean} True if the value is an instance of the schema.
+   */
+  isInstanceOf(value, type22) {
+    return this.isSchema(value) && type22._def.typeName === value._def.typeName;
+  }
+  /**
+   * Validate a value against a schema.
+   * @param {ZodCatchall} schema - The schema to validate against.
+   * @param {unknown} value - The value to validate.
+   * @returns {boolean} True if valid, otherwise false.
+   */
+  validate(schema, value) {
+    const resolvedSchema = this.schemify(schema);
+    return resolvedSchema.safeParse(value).success;
+  }
+  /**
+   * Parses a value to a schema validation.
+   *
+   * @param {ZodCatchall} schema - The schema to validate against.
+   * @param {unknown} value - The value to validate.
+   * @returns {ParseResult} - The discrimintated parsed value if successful, the error if unsuccessful.
+   */
+  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
+              }
+            ];
+        }
+      })
+    };
+  }
+  /**
+   * Convert a schema to an OpenAPI schema object.
+   * @param {ZodIdiomaticSchema} schema - The schema to convert.
+   * @returns {SchemaObject} The OpenAPI schema object.
+   */
+  openapi(schema) {
+    return (0, import_zod_openapi.generateSchema)(this.schemify(schema));
+  }
+};
+var SchemaValidator2 = () => new ZodSchemaValidator();
+var StaticSchemaValidator2 = SchemaValidator2();
+var string2 = StaticSchemaValidator2.string;
+var uuid2 = StaticSchemaValidator2.uuid;
+var email2 = StaticSchemaValidator2.email;
+var uri2 = StaticSchemaValidator2.uri;
+var number2 = StaticSchemaValidator2.number;
+var bigint2 = StaticSchemaValidator2.bigint;
+var boolean2 = StaticSchemaValidator2.boolean;
+var date2 = StaticSchemaValidator2.date;
+var symbol2 = StaticSchemaValidator2.symbol;
+var nullish2 = StaticSchemaValidator2.nullish;
+var void_2 = StaticSchemaValidator2.void;
+var null_2 = StaticSchemaValidator2.null;
+var undefined_2 = StaticSchemaValidator2.undefined;
+var any2 = StaticSchemaValidator2.any;
+var unknown2 = StaticSchemaValidator2.unknown;
+var never2 = StaticSchemaValidator2.never;
+var binary2 = StaticSchemaValidator2.binary;
+var file2 = StaticSchemaValidator2.file;
+var type2 = StaticSchemaValidator2.type;
+var schemify2 = StaticSchemaValidator2.schemify.bind(StaticSchemaValidator2);
+var optional2 = StaticSchemaValidator2.optional.bind(StaticSchemaValidator2);
+var array2 = StaticSchemaValidator2.array.bind(StaticSchemaValidator2);
+var union2 = StaticSchemaValidator2.union.bind(StaticSchemaValidator2);
+var literal2 = StaticSchemaValidator2.literal.bind(StaticSchemaValidator2);
+var enum_2 = StaticSchemaValidator2.enum_.bind(StaticSchemaValidator2);
+var function_2 = StaticSchemaValidator2.function_.bind(StaticSchemaValidator2);
+var record2 = StaticSchemaValidator2.record.bind(StaticSchemaValidator2);
+var promise2 = StaticSchemaValidator2.promise.bind(StaticSchemaValidator2);
+var isSchema2 = StaticSchemaValidator2.isSchema.bind(StaticSchemaValidator2);
+var validate2 = StaticSchemaValidator2.validate.bind(StaticSchemaValidator2);
+var parse2 = StaticSchemaValidator2.parse.bind(StaticSchemaValidator2);
+var openapi2 = StaticSchemaValidator2.openapi.bind(StaticSchemaValidator2);
+
+// schemas/zod/redisWorker.schema.ts
+var RedisWorkerOptionsSchema2 = {
+  pageSize: number2,
+  retries: number2,
+  interval: number2
+};
+
+// schemas/redisWorker.schema.ts
+var RedisWorkerSchemas = (0, import_mappers.serviceSchemaResolver)(
+  () => RedisWorkerOptionsSchema,
+  () => RedisWorkerOptionsSchema2
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedisWorkerSchemas
+});