@forklaunch/implementation-worker-kafka 1.0.33 → 1.0.35

package/lib/domain/schemas/index.js

@@ -15,7 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // domain/schemas/index.ts
@@ -28,1737 +27,26 @@ module.exports = __toCommonJS(schemas_exports);
 // domain/schemas/kafka.schema.ts
 var import_internal = require("@forklaunch/internal");
 
-// ../../../node_modules/.pnpm/@forklaunch+validator@1.2.26/node_modules/@forklaunch/validator/lib/src/typebox/index.mjs
-var typebox_exports = {};
-__export(typebox_exports, {
-  SchemaValidator: () => SchemaValidator,
-  TypeboxSchemaValidator: () => TypeboxSchemaValidator,
-  any: () => any,
-  array: () => array,
-  bigint: () => bigint,
-  binary: () => binary,
-  boolean: () => boolean,
-  date: () => date,
-  email: () => email,
-  enum_: () => enum_,
-  file: () => file,
-  function_: () => function_,
-  isSchema: () => isSchema,
-  literal: () => literal,
-  never: () => never,
-  null_: () => null_,
-  nullish: () => nullish,
-  number: () => number,
-  openapi: () => openapi,
-  optional: () => optional,
-  parse: () => parse,
-  promise: () => promise,
-  record: () => record,
-  schemify: () => schemify,
-  string: () => string,
-  symbol: () => symbol,
-  type: () => type,
-  undefined_: () => undefined_,
-  union: () => union,
-  unknown: () => unknown,
-  uri: () => uri,
-  uuid: () => uuid,
-  validate: () => validate,
-  void_: () => void_
-});
-__reExport(typebox_exports, require("@sinclair/typebox"));
-
-// ../../../node_modules/.pnpm/@forklaunch+common@1.2.25/node_modules/@forklaunch/common/lib/index.mjs
-function deepCloneWithoutUndefined(obj, seen = /* @__PURE__ */ new WeakMap()) {
-  if (obj === null || obj === void 0) {
-    return obj;
-  }
-  if (typeof obj !== "object" && typeof obj !== "function") {
-    return obj;
-  }
-  if (seen.has(obj)) {
-    return seen.get(obj);
-  }
-  if (obj instanceof Date) {
-    return new Date(obj.getTime());
-  }
-  if (obj instanceof RegExp) {
-    return new RegExp(obj.source, obj.flags);
-  }
-  if (obj instanceof Map) {
-    const clonedMap = /* @__PURE__ */ new Map();
-    seen.set(obj, clonedMap);
-    obj.forEach((value, key) => {
-      if (value !== void 0) {
-        clonedMap.set(key, deepCloneWithoutUndefined(value, seen));
-      }
-    });
-    return clonedMap;
-  }
-  if (obj instanceof Set) {
-    const clonedSet = /* @__PURE__ */ new Set();
-    seen.set(obj, clonedSet);
-    obj.forEach((value) => {
-      if (value !== void 0) {
-        clonedSet.add(deepCloneWithoutUndefined(value, seen));
-      }
-    });
-    return clonedSet;
-  }
-  if (Array.isArray(obj)) {
-    const clonedArray = [];
-    seen.set(obj, clonedArray);
-    for (const item of obj) {
-      if (item !== void 0) {
-        clonedArray.push(deepCloneWithoutUndefined(item, seen));
-      }
-    }
-    return clonedArray;
-  }
-  if (typeof obj === "function") {
-    return obj;
-  }
-  const proto = Object.getPrototypeOf(obj);
-  const cloned = Object.create(proto);
-  seen.set(obj, cloned);
-  const allKeys = [
-    ...Object.getOwnPropertyNames(obj),
-    ...Object.getOwnPropertySymbols(obj)
-  ];
-  for (const key of allKeys) {
-    const descriptor = Object.getOwnPropertyDescriptor(obj, key);
-    if (!descriptor) continue;
-    if ("value" in descriptor) {
-      if (descriptor.value !== void 0) {
-        Object.defineProperty(cloned, key, {
-          ...descriptor,
-          value: deepCloneWithoutUndefined(descriptor.value, seen)
-        });
-      }
-    } else {
-      Object.defineProperty(cloned, key, descriptor);
-    }
-  }
-  return cloned;
-}
-var InMemoryBlob = class extends Blob {
-  constructor(content) {
-    super([content]);
-    this.content = content;
-  }
-  content;
-};
-
-// ../../../node_modules/.pnpm/@forklaunch+validator@1.2.26/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");
-import_typebox.TypeRegistry.Set("Blob", (_schema, value) => value instanceof Blob);
-import_typebox.TypeRegistry.Set(
-  "ArrayBuffer",
-  (_schema, value) => value instanceof ArrayBuffer
-);
-import_typebox.TypeRegistry.Set("Buffer", (_schema, value) => value instanceof Buffer);
-(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-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
-    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 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 "";
-  });
-  file = import_typebox.Type.Transform(
-    import_typebox.Type.Union([
-      import_typebox.Type.Unsafe({
-        [import_typebox.Kind]: "Buffer",
-        errorType: "binary",
-        format: "binary",
-        example: "a raw buffer or file stream",
-        title: "File"
-      }),
-      import_typebox.Type.Unsafe({
-        [import_typebox.Kind]: "ArrayBuffer",
-        errorType: "binary",
-        format: "binary",
-        example: "an array buffer",
-        title: "File"
-      }),
-      import_typebox.Type.Unsafe({
-        [import_typebox.Kind]: "Blob",
-        errorType: "binary",
-        format: "binary",
-        example: "a blob object",
-        title: "File"
-      }),
-      import_typebox.Type.String({
-        errorType: "binary",
-        format: "binary",
-        example: "a string content",
-        title: "File"
-      })
-    ])
-  ).Decode((value) => {
-    if (value instanceof Buffer) {
-      return new InMemoryBlob(value);
-    }
-    if (value instanceof ArrayBuffer) {
-      return new InMemoryBlob(Buffer.from(value));
-    }
-    if (value instanceof Blob) {
-      return value;
-    }
-    if (typeof value === "string") {
-      return new InMemoryBlob(Buffer.from(value));
-    }
-    return new InMemoryBlob(Buffer.from(value));
-  }).Encode((value) => value.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 (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
-      return import_typebox.Type.Literal(schema);
-    }
-    if (import_typebox.KindGuard.IsSchema(schema) || schema instanceof import_compiler.TypeCheck) {
-      return schema;
-    }
-    const newSchema = {};
-    Object.getOwnPropertyNames(schema).forEach((key) => {
-      if (import_typebox.KindGuard.IsSchema(schema[key]) || import_typebox.KindGuard.IsTransform(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 (schemified[import_typebox.Kind] === "Unsafe") {
-        try {
-          if (value instanceof Buffer) {
-            conversion = new InMemoryBlob(value);
-          } else {
-            errors = [
-              {
-                type: import_errors.ValueErrorType.String,
-                schema: schemified,
-                path: "",
-                message: `Invalid file type: expected Buffer or string, got ${typeof value}`,
-                value,
-                errors: []
-              }
-            ];
-          }
-        } catch (err) {
-          errors = [
-            {
-              type: import_errors.ValueErrorType.String,
-              schema: schemified,
-              path: "",
-              message: err instanceof Error ? err.message : "Invalid file type",
-              value,
-              errors: []
-            }
-          ];
-        }
-      } else {
-        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) {
-    const schemified = this.schemify(schema);
-    let processedSchema;
-    if (import_typebox.KindGuard.IsDate(schemified)) {
-      processedSchema = import_typebox.Type.String({
-        format: "date-time"
-      });
-    } else {
-      processedSchema = deepCloneWithoutUndefined(schemified);
-    }
-    const newSchema = Object.assign({}, processedSchema);
-    if (Object.hasOwn(newSchema, "properties")) {
-      if (newSchema.properties) {
-        Object.entries({ ...processedSchema.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);
-
 // domain/schemas/typebox/kafkaWorker.schema.ts
+var import_typebox = require("@forklaunch/validator/typebox");
 var KafkaWorkerOptionsSchema = {
-  brokers: array(string),
-  clientId: string,
-  groupId: string,
-  retries: number,
-  interval: number,
-  peekCount: number
-};
-
-// ../../../node_modules/.pnpm/@forklaunch+validator@1.2.26/node_modules/@forklaunch/validator/lib/src/zod/index.mjs
-var import_v3 = require("zod/v3");
-
-// ../../../node_modules/.pnpm/ts-deepmerge@8.0.0/node_modules/ts-deepmerge/esm/index.js
-var isObject = (obj) => {
-  if (typeof obj === "object" && obj !== null) {
-    if (typeof Object.getPrototypeOf === "function") {
-      const prototype = Object.getPrototypeOf(obj);
-      return prototype === Object.prototype || prototype === null;
-    }
-    return Object.prototype.toString.call(obj) === "[object Object]";
-  }
-  return false;
-};
-var UNSAFE_KEYS = /* @__PURE__ */ new Set([
-  "__proto__",
-  "constructor",
-  "prototype",
-  "toString",
-  "valueOf",
-  "hasOwnProperty",
-  "isPrototypeOf",
-  "propertyIsEnumerable",
-  "toLocaleString"
-]);
-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 (UNSAFE_KEYS.has(key)) {
-      return;
-    }
-    if (Array.isArray(result[key]) && Array.isArray(current[key])) {
-      result[key] = merge.options.mergeArrays ? merge.options.uniqueArrayItems ? Array.from(new Set(result[key].concat(current[key]))) : [...result[key], ...current[key]] : current[key];
-    } else if (isObject(result[key]) && isObject(current[key])) {
-      result[key] = merge(result[key], current[key]);
-    } else if (!isObject(result[key]) && isObject(current[key])) {
-      result[key] = merge(current[key], void 0);
-    } else {
-      result[key] = current[key] === void 0 ? merge.options.allowUndefinedOverrides ? current[key] : result[key] : current[key];
-    }
-  });
-  return result;
-}, {});
-var defaultOptions = {
-  allowUndefinedOverrides: true,
-  mergeArrays: true,
-  uniqueArrayItems: true
-};
-merge.options = defaultOptions;
-merge.withOptions = (options, ...objects) => {
-  merge.options = Object.assign(Object.assign({}, defaultOptions), options);
-  const result = merge(...objects);
-  merge.options = defaultOptions;
-  return result;
-};
-
-// ../../../node_modules/.pnpm/@forklaunch+validator@1.2.26/node_modules/@forklaunch/validator/lib/src/zod/index.mjs
-var import_v32 = require("zod/v3");
-function extendApi(schema, schemaObject = {}) {
-  const This = schema.constructor;
-  const newSchema = new This(schema._def);
-  newSchema.metaOpenApi = Object.assign(
-    {},
-    schema.metaOpenApi || {},
-    schemaObject
-  );
-  return newSchema;
-}
-function iterateZodObject({
-  zodRef,
-  useOutput,
-  hideDefinitions,
-  openApiVersion
-}) {
-  const reduced = Object.keys(zodRef.shape).filter((key) => hideDefinitions?.includes(key) === false).reduce(
-    (carry, key) => ({
-      ...carry,
-      [key]: generateSchema(zodRef.shape[key], useOutput, openApiVersion)
-    }),
-    {}
-  );
-  return reduced;
-}
-function typeFormat(type22, openApiVersion) {
-  return openApiVersion === "3.0" ? type22 : [type22];
-}
-function parseTransformation({
-  zodRef,
-  schemas,
-  useOutput,
-  openApiVersion
-}) {
-  const input = generateSchema(zodRef._def.schema, useOutput, openApiVersion);
-  let output = "undefined";
-  if (useOutput && zodRef._def.effect) {
-    const effect = zodRef._def.effect.type === "transform" ? zodRef._def.effect : null;
-    if (effect && "transform" in effect) {
-      try {
-        const type22 = Array.isArray(input.type) ? input.type[0] : input.type;
-        output = typeof effect.transform(
-          ["integer", "number"].includes(`${type22}`) ? 0 : "string" === type22 ? "" : "boolean" === type22 ? false : "object" === type22 ? {} : "null" === type22 ? null : "array" === type22 ? [] : void 0,
-          { addIssue: () => void 0, path: [] }
-          // TODO: Discover if context is necessary here
-        );
-      } catch {
-      }
-    }
-  }
-  const outputType = output;
-  return merge(
-    {
-      ...zodRef.description ? { description: zodRef.description } : {},
-      ...input,
-      ...["number", "string", "boolean", "null"].includes(output) ? {
-        type: typeFormat(outputType, openApiVersion)
-      } : {}
-    },
-    ...schemas
-  );
-}
-function parseString({
-  zodRef,
-  schemas,
-  openApiVersion
-}) {
-  const baseSchema = {
-    type: typeFormat("string", openApiVersion)
-  };
-  const { checks = [] } = zodRef._def;
-  checks.forEach((item) => {
-    switch (item.kind) {
-      case "email":
-        baseSchema.format = "email";
-        break;
-      case "uuid":
-        baseSchema.format = "uuid";
-        break;
-      case "cuid":
-        baseSchema.format = "cuid";
-        break;
-      case "url":
-        baseSchema.format = "uri";
-        break;
-      case "datetime":
-        baseSchema.format = "date-time";
-        break;
-      case "length":
-        baseSchema.minLength = item.value;
-        baseSchema.maxLength = item.value;
-        break;
-      case "max":
-        baseSchema.maxLength = item.value;
-        break;
-      case "min":
-        baseSchema.minLength = item.value;
-        break;
-      case "regex":
-        baseSchema.pattern = item.regex.source;
-        break;
-    }
-  });
-  return merge(
-    baseSchema,
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseNumber({
-  zodRef,
-  schemas,
-  openApiVersion
-}) {
-  const baseSchema = {
-    type: typeFormat("number", openApiVersion)
-  };
-  const { checks = [] } = zodRef._def;
-  checks.forEach((item) => {
-    switch (item.kind) {
-      case "max":
-        if (item.inclusive || openApiVersion === "3.0") {
-          baseSchema.maximum = item.value;
-        }
-        if (!item.inclusive) {
-          if (openApiVersion === "3.0") {
-            baseSchema.exclusiveMaximum = true;
-          } else {
-            baseSchema.exclusiveMaximum = item.value;
-          }
-        }
-        break;
-      case "min":
-        if (item.inclusive || openApiVersion === "3.0") {
-          baseSchema.minimum = item.value;
-        }
-        if (!item.inclusive) {
-          if (openApiVersion === "3.0") {
-            baseSchema.exclusiveMinimum = true;
-          } else {
-            baseSchema.exclusiveMinimum = item.value;
-          }
-        }
-        break;
-      case "int":
-        baseSchema.type = typeFormat("integer", openApiVersion);
-        break;
-      case "multipleOf":
-        baseSchema.multipleOf = item.value;
-        break;
-    }
-  });
-  return merge(
-    baseSchema,
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function getExcludedDefinitionsFromSchema(schemas) {
-  const excludedDefinitions = [];
-  for (const schema of schemas) {
-    if (Array.isArray(schema.hideDefinitions)) {
-      excludedDefinitions.push(...schema.hideDefinitions);
-    }
-  }
-  return excludedDefinitions;
-}
-function parseObject({
-  zodRef,
-  schemas,
-  useOutput,
-  hideDefinitions,
-  openApiVersion
-}) {
-  let additionalProperties;
-  if (!(zodRef._def.catchall instanceof import_v32.z.ZodNever || zodRef._def.catchall?._def.typeName === "ZodNever"))
-    additionalProperties = generateSchema(
-      zodRef._def.catchall,
-      useOutput,
-      openApiVersion
-    );
-  else if (zodRef._def.unknownKeys === "passthrough")
-    additionalProperties = true;
-  else if (zodRef._def.unknownKeys === "strict") additionalProperties = false;
-  additionalProperties = additionalProperties != null ? { additionalProperties } : {};
-  const requiredProperties = Object.keys(
-    zodRef.shape
-  ).filter((key) => {
-    const item = zodRef.shape[key];
-    return !(item.isOptional() || item instanceof import_v32.z.ZodDefault || item._def.typeName === "ZodDefault") && !(item instanceof import_v32.z.ZodNever || item._def.typeName === "ZodDefault");
-  });
-  const required = requiredProperties.length > 0 ? { required: requiredProperties } : {};
-  return merge(
-    {
-      type: typeFormat("object", openApiVersion),
-      properties: iterateZodObject({
-        zodRef,
-        schemas,
-        useOutput,
-        hideDefinitions: getExcludedDefinitionsFromSchema(schemas),
-        openApiVersion
-      }),
-      ...required,
-      ...additionalProperties,
-      ...hideDefinitions
-    },
-    zodRef.description ? { description: zodRef.description, hideDefinitions } : {},
-    ...schemas
-  );
-}
-function parseRecord({
-  zodRef,
-  schemas,
-  useOutput,
-  openApiVersion
-}) {
-  return merge(
-    {
-      type: typeFormat("object", openApiVersion),
-      additionalProperties: zodRef._def.valueType instanceof import_v32.z.ZodUnknown ? {} : generateSchema(zodRef._def.valueType, useOutput, openApiVersion)
-    },
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseBigInt({
-  zodRef,
-  schemas,
-  openApiVersion
-}) {
-  return merge(
-    {
-      type: typeFormat("integer", openApiVersion),
-      format: "int64"
-    },
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseBoolean({
-  zodRef,
-  schemas,
-  openApiVersion
-}) {
-  return merge(
-    { type: typeFormat("boolean", openApiVersion) },
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseDate({
-  zodRef,
-  schemas,
-  openApiVersion
-}) {
-  return merge(
-    {
-      type: typeFormat("string", openApiVersion),
-      format: "date-time"
-    },
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseNull({
-  zodRef,
-  schemas,
-  openApiVersion
-}) {
-  return merge(
-    openApiVersion === "3.0" ? { type: "null" } : {
-      type: ["string", "null"],
-      enum: ["null"]
-    },
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseOptional({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
-  return merge(
-    generateSchema(zodRef.unwrap(), useOutput, openApiVersion),
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseNullable({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
-  const schema = generateSchema(zodRef.unwrap(), useOutput, openApiVersion);
-  return merge(
-    schema,
-    openApiVersion === "3.0" ? { nullable: true } : { type: typeFormat("null", openApiVersion) },
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseDefault({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
-  return merge(
-    {
-      default: zodRef._def.defaultValue(),
-      ...generateSchema(zodRef._def.innerType, useOutput, openApiVersion)
-    },
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseArray({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
-  const constraints = {};
-  if (zodRef._def.exactLength != null) {
-    constraints.minItems = zodRef._def.exactLength.value;
-    constraints.maxItems = zodRef._def.exactLength.value;
-  }
-  if (zodRef._def.minLength != null)
-    constraints.minItems = zodRef._def.minLength.value;
-  if (zodRef._def.maxLength != null)
-    constraints.maxItems = zodRef._def.maxLength.value;
-  return merge(
-    {
-      type: typeFormat("array", openApiVersion),
-      items: generateSchema(zodRef.element, useOutput, openApiVersion),
-      ...constraints
-    },
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseLiteral({
-  schemas,
-  zodRef,
-  openApiVersion
-}) {
-  const type22 = typeof zodRef._def.value;
-  return merge(
-    {
-      type: typeFormat(type22, openApiVersion),
-      enum: [zodRef._def.value]
-    },
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseEnum({
-  schemas,
-  zodRef,
-  openApiVersion
-}) {
-  const type22 = typeof Object.values(zodRef._def.values)[0];
-  return merge(
-    {
-      type: typeFormat(type22, openApiVersion),
-      enum: Object.values(zodRef._def.values)
-    },
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseIntersection({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
-  return merge(
-    {
-      allOf: [
-        generateSchema(zodRef._def.left, useOutput, openApiVersion),
-        generateSchema(zodRef._def.right, useOutput, openApiVersion)
-      ]
-    },
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseUnion({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
-  const contents = zodRef._def.options;
-  if (contents.reduce(
-    (prev, content) => prev && content._def.typeName === "ZodLiteral",
-    true
-  )) {
-    const literals = contents;
-    const type22 = literals.reduce(
-      (prev, content) => !prev || prev === typeof content._def.value ? typeof content._def.value : null,
-      null
-    );
-    if (type22) {
-      return merge(
-        {
-          type: typeFormat(type22, openApiVersion),
-          enum: literals.map((literal22) => literal22._def.value)
-        },
-        zodRef.description ? { description: zodRef.description } : {},
-        ...schemas
-      );
-    }
-  }
-  const oneOfContents = openApiVersion === "3.0" ? contents.filter((content) => content._def.typeName !== "ZodNull") : contents;
-  const contentsHasNull = contents.length != oneOfContents.length;
-  return merge(
-    {
-      oneOf: oneOfContents.map(
-        (schema) => generateSchema(schema, useOutput, openApiVersion)
-      )
-    },
-    contentsHasNull ? { nullable: true } : {},
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseDiscriminatedUnion({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
-  return merge(
-    {
-      discriminator: {
-        propertyName: zodRef._def.discriminator
-      },
-      oneOf: Array.from(
-        zodRef._def.options.values()
-      ).map((schema) => generateSchema(schema, useOutput, openApiVersion))
-    },
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseNever({
-  zodRef,
-  schemas
-}) {
-  return merge(
-    { readOnly: true },
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parseBranded({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
-  return merge(
-    generateSchema(zodRef._def.type, useOutput, openApiVersion),
-    ...schemas
-  );
-}
-function catchAllParser({
-  zodRef,
-  schemas
-}) {
-  return merge(
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-function parsePipeline({
-  schemas,
-  zodRef,
-  useOutput,
-  openApiVersion
-}) {
-  return merge(
-    generateSchema(
-      useOutput ? zodRef._def.out : zodRef._def.in,
-      useOutput,
-      openApiVersion
-    ),
-    ...schemas
-  );
-}
-function parseReadonly({
-  zodRef,
-  useOutput,
-  schemas,
-  openApiVersion
-}) {
-  return merge(
-    generateSchema(zodRef._def.innerType, useOutput, openApiVersion),
-    zodRef.description ? { description: zodRef.description } : {},
-    ...schemas
-  );
-}
-var workerMap = {
-  ZodObject: parseObject,
-  ZodRecord: parseRecord,
-  ZodString: parseString,
-  ZodNumber: parseNumber,
-  ZodBigInt: parseBigInt,
-  ZodBoolean: parseBoolean,
-  ZodDate: parseDate,
-  ZodNull: parseNull,
-  ZodOptional: parseOptional,
-  ZodNullable: parseNullable,
-  ZodDefault: parseDefault,
-  ZodArray: parseArray,
-  ZodLiteral: parseLiteral,
-  ZodEnum: parseEnum,
-  ZodNativeEnum: parseEnum,
-  ZodTransformer: parseTransformation,
-  ZodEffects: parseTransformation,
-  ZodIntersection: parseIntersection,
-  ZodUnion: parseUnion,
-  ZodDiscriminatedUnion: parseDiscriminatedUnion,
-  ZodNever: parseNever,
-  ZodBranded: parseBranded,
-  // TODO Transform the rest to schemas
-  ZodUndefined: catchAllParser,
-  // TODO: `prefixItems` is allowed in OpenAPI 3.1 which can be used to create tuples
-  ZodTuple: catchAllParser,
-  ZodMap: catchAllParser,
-  ZodFunction: catchAllParser,
-  ZodLazy: catchAllParser,
-  ZodPromise: catchAllParser,
-  ZodAny: catchAllParser,
-  ZodUnknown: catchAllParser,
-  ZodVoid: catchAllParser,
-  ZodPipeline: parsePipeline,
-  ZodReadonly: parseReadonly
-};
-function generateSchema(zodRef, useOutput = false, openApiVersion = "3.1") {
-  const { metaOpenApi = {} } = zodRef;
-  const schemas = [
-    ...Array.isArray(metaOpenApi) ? metaOpenApi : [metaOpenApi]
-  ];
-  try {
-    const typeName = zodRef._def.typeName;
-    if (typeName in workerMap) {
-      return workerMap[typeName]({
-        zodRef,
-        schemas,
-        useOutput,
-        openApiVersion
-      });
-    }
-    return catchAllParser({ zodRef, schemas, openApiVersion });
-  } catch (err) {
-    console.error(err);
-    return catchAllParser({ zodRef, schemas, openApiVersion });
-  }
-}
-function extendZodWithOpenApi(zod, forceOverride = false) {
-  if (!forceOverride && typeof zod.ZodSchema.prototype.openapi !== "undefined") {
-    return;
-  }
-  zod.ZodSchema.prototype.openapi = function(metadata) {
-    return extendApi(this, metadata);
-  };
-}
-extendZodWithOpenApi(import_v3.z);
-var ZodSchemaValidator = class {
-  _Type = "Zod";
-  _SchemaCatchall;
-  _ValidSchemaObject;
-  string = import_v3.z.string().openapi({
-    title: "String",
-    example: "a string"
-  });
-  uuid = import_v3.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_v3.z.string().email().openapi({
-    title: "Email",
-    format: "email",
-    pattern: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
-    example: "a@b.com"
-  });
-  uri = import_v3.z.string().url().openapi({
-    title: "URI",
-    format: "uri",
-    pattern: "^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$",
-    example: "https://forklaunch.com"
-  });
-  number = import_v3.z.preprocess((value) => {
-    try {
-      return Number(value);
-    } catch {
-      return value;
-    }
-  }, import_v3.z.number()).openapi({
-    title: "Number",
-    example: 123
-  });
-  bigint = import_v3.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_v3.z.bigint()).openapi({
-    title: "BigInt",
-    type: "integer",
-    format: "int64",
-    example: 123n
-  });
-  boolean = import_v3.z.preprocess((val) => {
-    if (typeof val === "string") {
-      if (val.toLowerCase() === "true") return true;
-      if (val.toLowerCase() === "false") return false;
-    }
-    return val;
-  }, import_v3.z.boolean()).openapi({
-    title: "Boolean",
-    example: true
-  });
-  date = import_v3.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_v3.z.date()).openapi({
-    title: "Date",
-    type: "string",
-    format: "date-time",
-    example: "2025-05-16T21:13:04.123Z"
-  });
-  symbol = import_v3.z.symbol().openapi({
-    title: "Symbol",
-    example: /* @__PURE__ */ Symbol("symbol")
-  });
-  nullish = import_v3.z.union([import_v3.z.void(), import_v3.z.null(), import_v3.z.undefined()]).openapi({
-    title: "Nullish",
-    type: "null",
-    example: null
-  });
-  void = import_v3.z.void().openapi({
-    title: "Void",
-    type: "null",
-    example: void 0
-  });
-  null = import_v3.z.null().openapi({
-    title: "Null",
-    type: "null",
-    example: null
-  });
-  undefined = import_v3.z.undefined().openapi({
-    title: "Undefined",
-    type: "null",
-    example: void 0
-  });
-  any = import_v3.z.any().openapi({
-    title: "Any",
-    type: "object",
-    example: "any"
-  });
-  unknown = import_v3.z.unknown().openapi({
-    title: "Unknown",
-    type: "object",
-    example: "unknown"
-  });
-  never = import_v3.z.never().openapi({
-    title: "Never",
-    type: "null",
-    example: "never"
-  });
-  binary = import_v3.z.string().transform((val) => new Uint8Array(Buffer.from(val, "base64"))).openapi({
-    title: "Binary",
-    type: "string",
-    format: "binary",
-    example: "a base-64 encodable string"
-  });
-  file = import_v3.z.union([
-    import_v3.z.instanceof(Buffer),
-    import_v3.z.instanceof(ArrayBuffer),
-    import_v3.z.instanceof(Blob),
-    import_v3.z.string()
-  ]).transform((val) => {
-    if (val instanceof Buffer) {
-      return new Blob([val]);
-    }
-    if (val instanceof ArrayBuffer) {
-      return new Blob([val]);
-    }
-    if (val instanceof Blob) {
-      return val;
-    }
-    if (typeof val === "string") {
-      return new Blob([val]);
-    }
-    return new Blob([val]);
-  }).refine((val) => val instanceof Blob, {
-    message: "Invalid file type: expected Buffer, ArrayBuffer, Blob, or string"
-  }).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.
-   *
-   * @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_v3.z.literal(schema);
-    }
-    if (schema instanceof import_v3.ZodType) {
-      return schema;
-    }
-    const newSchema = {};
-    Object.getOwnPropertyNames(schema).forEach((key) => {
-      if (schema[key] instanceof import_v3.ZodType) {
-        newSchema[key] = schema[key];
-      } else {
-        newSchema[key] = this.schemify(schema[key]);
-      }
-    });
-    return import_v3.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_v3.z.union(
-      resolvedSchemas
-    );
-  }
-  /**
-   * Create a literal schema.
-   * @param {LiteralSchema} value - The literal value.
-   * @returns {ZodLiteral<ZodResolve<T>>} The literal schema.
-   */
-  literal(value) {
-    return import_v3.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_v3.z.function(import_v3.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_v3.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_v3.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_v3.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) {
-    const schemified = this.schemify(schema);
-    return generateSchema(deepCloneWithoutUndefined(schemified));
-  }
+  brokers: (0, import_typebox.array)(import_typebox.string),
+  clientId: import_typebox.string,
+  groupId: import_typebox.string,
+  retries: import_typebox.number,
+  interval: import_typebox.number,
+  peekCount: import_typebox.number
 };
-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);
 
 // domain/schemas/zod/kafkaWorker.schema.ts
+var import_zod = require("@forklaunch/validator/zod");
 var KafkaWorkerOptionsSchema2 = {
-  brokers: array2(string2),
-  clientId: string2,
-  groupId: string2,
-  retries: number2,
-  interval: number2,
-  peekCount: number2
+  brokers: (0, import_zod.array)(import_zod.string),
+  clientId: import_zod.string,
+  groupId: import_zod.string,
+  retries: import_zod.number,
+  interval: import_zod.number,
+  peekCount: import_zod.number
 };
 
 // domain/schemas/kafka.schema.ts