@forklaunch/validator 0.4.6 → 0.4.8

package/lib/{tests → __test__}/utils/mockSchemaValidator.d.mts

@@ -1,5 +1,5 @@
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { S as SchemaValidator, L as LiteralSchema, a as ParseResult } from '../../schema.types-CA4Aof4g.mjs';
+import { S as SchemaValidator, L as LiteralSchema, a as ParseResult } from '../../schema.types-CoFRq_Vn.mjs';
 import '@forklaunch/common';
 import '@sinclair/typebox';
 import '@sinclair/typebox/compiler';

package/lib/{tests → __test__}/utils/mockSchemaValidator.d.ts

@@ -1,5 +1,5 @@
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { S as SchemaValidator, L as LiteralSchema, a as ParseResult } from '../../schema.types-CA4Aof4g.js';
+import { S as SchemaValidator, L as LiteralSchema, a as ParseResult } from '../../schema.types-CoFRq_Vn.js';
 import '@forklaunch/common';
 import '@sinclair/typebox';
 import '@sinclair/typebox/compiler';

package/lib/{tests → __test__}/utils/mockSchemaValidator.js

@@ -17,7 +17,7 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// tests/utils/mockSchemaValidator.ts
+// __test__/utils/mockSchemaValidator.ts
 var mockSchemaValidator_exports = {};
 __export(mockSchemaValidator_exports, {
   MockSchemaValidator: () => MockSchemaValidator,
@@ -96,7 +96,9 @@ var MockSchemaValidator = class {
     };
   }
   openapi(_schema) {
-    return {};
+    return {
+      type: "string"
+    };
   }
 };
 var mockSchemaValidator = new MockSchemaValidator();

package/lib/{tests → __test__}/utils/mockSchemaValidator.mjs

@@ -1,4 +1,4 @@
-// tests/utils/mockSchemaValidator.ts
+// __test__/utils/mockSchemaValidator.ts
 var MockSchemaValidator = class {
   _Type;
   _SchemaCatchall;
@@ -53,7 +53,9 @@ var MockSchemaValidator = class {
     };
   }
   openapi(_schema) {
-    return {};
+    return {
+      type: "string"
+    };
   }
 };
 var mockSchemaValidator = new MockSchemaValidator();

package/lib/index.d.mts

@@ -1,5 +1,5 @@
-import { P as ParseError } from './schema.types-CA4Aof4g.mjs';
-export { A as AnySchemaValidator, I as IdiomaticSchema, e as Increment, K as KeyTypes, L as LiteralSchema, a as ParseResult, d as Schema, b as SchemaResolve, c as SchemaTranslate, S as SchemaValidator, U as UnboxedObjectSchema } from './schema.types-CA4Aof4g.mjs';
+import { P as ParseError } from './schema.types-CoFRq_Vn.mjs';
+export { A as AnySchemaValidator, I as IdiomaticSchema, e as Increment, K as KeyTypes, L as LiteralSchema, a as ParseResult, d as Schema, b as SchemaResolve, c as SchemaTranslate, S as SchemaValidator, U as UnboxedObjectSchema } from './schema.types-CoFRq_Vn.mjs';
 import '@forklaunch/common';
 import 'openapi3-ts/oas31';
 import '@sinclair/typebox';

package/lib/index.d.ts

@@ -1,5 +1,5 @@
-import { P as ParseError } from './schema.types-CA4Aof4g.js';
-export { A as AnySchemaValidator, I as IdiomaticSchema, e as Increment, K as KeyTypes, L as LiteralSchema, a as ParseResult, d as Schema, b as SchemaResolve, c as SchemaTranslate, S as SchemaValidator, U as UnboxedObjectSchema } from './schema.types-CA4Aof4g.js';
+import { P as ParseError } from './schema.types-CoFRq_Vn.js';
+export { A as AnySchemaValidator, I as IdiomaticSchema, e as Increment, K as KeyTypes, L as LiteralSchema, a as ParseResult, d as Schema, b as SchemaResolve, c as SchemaTranslate, S as SchemaValidator, U as UnboxedObjectSchema } from './schema.types-CoFRq_Vn.js';
 import '@forklaunch/common';
 import 'openapi3-ts/oas31';
 import '@sinclair/typebox';

package/lib/{schema.types-CA4Aof4g.d.mts → schema.types-CoFRq_Vn.d.mts}

@@ -1,6 +1,6 @@
 import { Prettify } from '@forklaunch/common';
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { TUnknown, TLiteral, TSchema, TKind, TProperties, TObject as TObject$1, TNever, StaticDecode } from '@sinclair/typebox';
+import { TUnknown, TLiteral, TSchema, TKind, TProperties, TObject as TObject$1, TNever, StaticDecode, TArray } from '@sinclair/typebox';
 import { TypeCheck } from '@sinclair/typebox/compiler';
 import { ZodObject as ZodObject$1, ZodRawShape, ZodOptional, ZodArray, ZodUnion, ZodLiteral, ZodType, z, ZodUnknown, ZodNever, ZodTypeAny } from 'zod';
 
@@ -8,6 +8,12 @@ import { ZodObject as ZodObject$1, ZodRawShape, ZodOptional, ZodArray, ZodUnion,
  * Represents a catch-all schema type.
  */
 type TCatchall = TSchema;
+/**
+ * Represents an outer array schema type. If the type T is an object shape, it will return an array schema of T. Otherwise, it returns TNever.
+ *
+ * @template T - The type to check and possibly convert to an array schema.
+ */
+type TOuterArray<T> = T extends TObject<TObjectShape> ? TArray<T> : TNever;
 /**
  * Represents the shape of an object schema.
  */
@@ -50,7 +56,7 @@ type UnionTResolve<T extends TUnionContainer> = T extends (infer UnionTypes)[] ?
  * @template T - The schema type to resolve.
  * @template Depth - The current depth of the resolution.
  */
-type TResolve<T, Depth extends number = 0> = Depth extends 12 ? TUnknown : T extends LiteralSchema ? TLiteral<T> : T extends TSchema ? T : T extends TKind ? T : T extends TObject<TObjectShape> ? T : T extends UnboxedTObjectSchema ? TObject<{
+type TResolve<T, Depth extends number = 0> = Depth extends 10 ? TUnknown : T extends LiteralSchema ? TLiteral<T> : T extends TSchema ? T : T extends TKind ? T : T extends TObject<TObjectShape> ? T : T extends UnboxedTObjectSchema ? TObject<{
     [K in keyof T]: TResolve<T[K], Increment<Depth>>;
 }> : T extends TypeCheck<infer Type> ? TResolve<Type, Increment<Depth>> : TNever;
 
@@ -65,7 +71,11 @@ type TResolve<T, Depth extends number = 0> = Depth extends 12 ? TUnknown : T ext
  * Class representing a Zod schema definition.
  * @implements {StaticSchemaValidator}
  */
-declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObject$1<ZodRawShape>>(schema: T) => ZodResolve<T>), <T extends ZodIdiomaticSchema>(schema: T) => ZodResolve<T>, <T extends ZodIdiomaticSchema>(schema: T) => ZodOptional<ZodResolve<T>>, <T extends ZodIdiomaticSchema>(schema: T) => ZodArray<ZodResolve<T>>, <T extends ZodUnionContainer>(schemas: T) => ZodUnion<UnionZodResolve<T>>, <T extends LiteralSchema>(value: T) => ZodLiteral<ZodResolve<T>>, <T extends LiteralSchema>(schemaEnum: Record<string, T>) => ZodUnion<UnionZodResolve<[T, T, ...T[]]>>, (value: unknown) => value is ZodType, <T extends ZodCatchall>(schema: T, value: unknown) => boolean, <T extends ZodCatchall>(schema: T, value: unknown) => ParseResult<ZodResolve<T>>, <T extends ZodIdiomaticSchema>(schema: T) => SchemaObject> {
+declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObject$1<ZodRawShape>>(schema: T) => ZodResolve<T>), <T extends ZodIdiomaticSchema>(schema: T) => ZodResolve<T>, <T extends ZodIdiomaticSchema>(schema: T) => ZodOptional<ZodResolve<T>>, <T extends ZodIdiomaticSchema>(schema: T) => ZodArray<ZodResolve<T>>, <T extends ZodUnionContainer>(schemas: T) => ZodUnion<UnionZodResolve<T>>, <T extends LiteralSchema>(value: T) => ZodLiteral<ZodResolve<T>>, <T extends Record<string, LiteralSchema>>(schemaEnum: T) => ZodUnion<[
+    {
+        [K in keyof T]: ZodLiteral<T[K]>;
+    }[keyof T]
+]>, (value: unknown) => value is ZodType, <T extends ZodIdiomaticSchema | ZodCatchall>(schema: T, value: unknown) => boolean, <T extends ZodIdiomaticSchema | ZodCatchall>(schema: T, value: unknown) => ParseResult<ZodResolve<T>>, <T extends ZodIdiomaticSchema | ZodCatchall>(schema: T) => SchemaObject> {
     _Type: 'Zod';
     _SchemaCatchall: ZodType;
     _ValidSchemaObject: ZodObject$1<ZodRawShape> | ZodArray<ZodObject$1<ZodRawShape>>;
@@ -124,7 +134,11 @@ declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObjec
      * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
      * @returns {ZodUnion<UnionZodResolve<[T, T, ...T[]]>>} The enum schema.
      */
-    enum_<T extends LiteralSchema>(schemaEnum: Record<string, T>): ZodUnion<UnionZodResolve<[T, T, ...T[]]>>;
+    enum_<T extends Record<string, LiteralSchema>>(schemaEnum: T): ZodUnion<[
+        {
+            [K in keyof T]: ZodLiteral<T[K]>;
+        }[keyof T]
+    ]>;
     /**
      * Checks if a value is a Zod schema.
      * @param {unknown} value - The value to check.
@@ -137,7 +151,7 @@ declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObjec
      * @param {unknown} value - The value to validate.
      * @returns {boolean} True if valid, otherwise false.
      */
-    validate<T extends ZodCatchall>(schema: T, value: unknown): boolean;
+    validate<T extends ZodIdiomaticSchema | ZodCatchall>(schema: T, value: unknown): boolean;
     /**
      * Parses a value to a schema validation.
      *
@@ -145,19 +159,25 @@ declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObjec
      * @param {unknown} value - The value to validate.
      * @returns {ParseResult} - The discrimintated parsed value if successful, the error if unsuccessful.
      */
-    parse<T extends ZodCatchall>(schema: T, value: unknown): ParseResult<ZodResolve<T>>;
+    parse<T extends ZodIdiomaticSchema | ZodCatchall>(schema: T, value: unknown): ParseResult<ZodResolve<T>>;
     /**
      * Convert a schema to an OpenAPI schema object.
      * @param {ZodIdiomaticSchema} schema - The schema to convert.
      * @returns {SchemaObject} The OpenAPI schema object.
      */
-    openapi<T extends ZodIdiomaticSchema>(schema: T): SchemaObject;
+    openapi<T extends ZodIdiomaticSchema | ZodCatchall>(schema: T): SchemaObject;
 }
 
 /**
  * Represents a catch-all Zod schema type.
  */
 type ZodCatchall = ZodTypeAny;
+/**
+ * Represents an outer array schema type for Zod. If the type T is a Zod object, it will return an array schema of T. Otherwise, it returns ZodNever.
+ *
+ * @template T - The type to check and possibly convert to an array schema.
+ */
+type ZodOuterArray<T> = T extends ZodObject<ZodObjectShape> ? ZodArray<T> : ZodNever;
 /**
  * Represents the shape of a Zod object schema.
  */
@@ -177,7 +197,7 @@ type ZodSchemaTranslate<T> = T extends ZodCatchall ? z.infer<T> : ZodNever;
 /**
  * Represents an unboxed Zod object schema where each key can have an idiomatic schema.
  */
-type ZodObjectSchema = UnboxedObjectSchema<ZodSchemaValidator>;
+type UnboxedZodObjectSchema = UnboxedObjectSchema<ZodSchemaValidator>;
 /**
  * Represents an idiomatic schema for Zod which can be an unboxed object schema or a literal schema.
  */
@@ -212,7 +232,7 @@ type UnionZodResolve<T extends ZodUnionContainer> = T extends [
  * @template T - The Zod schema type to resolve.
  * @template Depth - The current depth of the resolution.
  */
-type ZodResolve<T, Depth extends number = 0> = Depth extends 31 ? ZodUnknown : T extends LiteralSchema ? ZodLiteral<T> : T extends ZodType ? T : T extends ZodObjectSchema ? ZodObject<{
+type ZodResolve<T, Depth extends number = 0> = Depth extends 30 ? ZodUnknown : T extends LiteralSchema ? ZodLiteral<T> : T extends ZodType ? T : T extends UnboxedZodObjectSchema ? ZodObject<{
     [K in keyof T]: ZodResolve<T[K], Increment<Depth>>;
 }> : ZodNever;
 
@@ -473,4 +493,4 @@ type Increment<T extends number> = T extends 0 ? 1 : T extends 1 ? 2 : T extends
  */
 type KeyTypes = string | number;
 
-export { type AnySchemaValidator as A, type IdiomaticSchema as I, type KeyTypes as K, type LiteralSchema as L, type ParseError as P, type SchemaValidator as S, type TObject as T, type UnboxedObjectSchema as U, ZodSchemaValidator as Z, type ParseResult as a, type SchemaResolve as b, type SchemaTranslate as c, type Schema as d, type Increment as e, type TIdiomaticSchema as f, type TResolve as g, type TUnionContainer as h, type UnionTResolve as i, type ZodIdiomaticSchema as j, type ZodResolve as k, type ZodUnionContainer as l, type UnionZodResolve as m, type ZodCatchall as n };
+export { type AnySchemaValidator as A, type IdiomaticSchema as I, type KeyTypes as K, type LiteralSchema as L, type ParseError as P, type SchemaValidator as S, type TObject as T, type UnboxedObjectSchema as U, ZodSchemaValidator as Z, type ParseResult as a, type SchemaResolve as b, type SchemaTranslate as c, type Schema as d, type Increment as e, type TIdiomaticSchema as f, type TResolve as g, type TUnionContainer as h, type UnionTResolve as i, type TCatchall as j, type TOuterArray as k, type TObjectShape as l, type TSchemaTranslate as m, type UnboxedTObjectSchema as n, type ZodIdiomaticSchema as o, type ZodResolve as p, type ZodUnionContainer as q, type UnionZodResolve as r, type ZodCatchall as s, type ZodOuterArray as t, type ZodObjectShape as u, type ZodObject as v, type ZodSchemaTranslate as w, type UnboxedZodObjectSchema as x };

package/lib/{schema.types-CA4Aof4g.d.ts → schema.types-CoFRq_Vn.d.ts}

@@ -1,6 +1,6 @@
 import { Prettify } from '@forklaunch/common';
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { TUnknown, TLiteral, TSchema, TKind, TProperties, TObject as TObject$1, TNever, StaticDecode } from '@sinclair/typebox';
+import { TUnknown, TLiteral, TSchema, TKind, TProperties, TObject as TObject$1, TNever, StaticDecode, TArray } from '@sinclair/typebox';
 import { TypeCheck } from '@sinclair/typebox/compiler';
 import { ZodObject as ZodObject$1, ZodRawShape, ZodOptional, ZodArray, ZodUnion, ZodLiteral, ZodType, z, ZodUnknown, ZodNever, ZodTypeAny } from 'zod';
 
@@ -8,6 +8,12 @@ import { ZodObject as ZodObject$1, ZodRawShape, ZodOptional, ZodArray, ZodUnion,
  * Represents a catch-all schema type.
  */
 type TCatchall = TSchema;
+/**
+ * Represents an outer array schema type. If the type T is an object shape, it will return an array schema of T. Otherwise, it returns TNever.
+ *
+ * @template T - The type to check and possibly convert to an array schema.
+ */
+type TOuterArray<T> = T extends TObject<TObjectShape> ? TArray<T> : TNever;
 /**
  * Represents the shape of an object schema.
  */
@@ -50,7 +56,7 @@ type UnionTResolve<T extends TUnionContainer> = T extends (infer UnionTypes)[] ?
  * @template T - The schema type to resolve.
  * @template Depth - The current depth of the resolution.
  */
-type TResolve<T, Depth extends number = 0> = Depth extends 12 ? TUnknown : T extends LiteralSchema ? TLiteral<T> : T extends TSchema ? T : T extends TKind ? T : T extends TObject<TObjectShape> ? T : T extends UnboxedTObjectSchema ? TObject<{
+type TResolve<T, Depth extends number = 0> = Depth extends 10 ? TUnknown : T extends LiteralSchema ? TLiteral<T> : T extends TSchema ? T : T extends TKind ? T : T extends TObject<TObjectShape> ? T : T extends UnboxedTObjectSchema ? TObject<{
     [K in keyof T]: TResolve<T[K], Increment<Depth>>;
 }> : T extends TypeCheck<infer Type> ? TResolve<Type, Increment<Depth>> : TNever;
 
@@ -65,7 +71,11 @@ type TResolve<T, Depth extends number = 0> = Depth extends 12 ? TUnknown : T ext
  * Class representing a Zod schema definition.
  * @implements {StaticSchemaValidator}
  */
-declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObject$1<ZodRawShape>>(schema: T) => ZodResolve<T>), <T extends ZodIdiomaticSchema>(schema: T) => ZodResolve<T>, <T extends ZodIdiomaticSchema>(schema: T) => ZodOptional<ZodResolve<T>>, <T extends ZodIdiomaticSchema>(schema: T) => ZodArray<ZodResolve<T>>, <T extends ZodUnionContainer>(schemas: T) => ZodUnion<UnionZodResolve<T>>, <T extends LiteralSchema>(value: T) => ZodLiteral<ZodResolve<T>>, <T extends LiteralSchema>(schemaEnum: Record<string, T>) => ZodUnion<UnionZodResolve<[T, T, ...T[]]>>, (value: unknown) => value is ZodType, <T extends ZodCatchall>(schema: T, value: unknown) => boolean, <T extends ZodCatchall>(schema: T, value: unknown) => ParseResult<ZodResolve<T>>, <T extends ZodIdiomaticSchema>(schema: T) => SchemaObject> {
+declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObject$1<ZodRawShape>>(schema: T) => ZodResolve<T>), <T extends ZodIdiomaticSchema>(schema: T) => ZodResolve<T>, <T extends ZodIdiomaticSchema>(schema: T) => ZodOptional<ZodResolve<T>>, <T extends ZodIdiomaticSchema>(schema: T) => ZodArray<ZodResolve<T>>, <T extends ZodUnionContainer>(schemas: T) => ZodUnion<UnionZodResolve<T>>, <T extends LiteralSchema>(value: T) => ZodLiteral<ZodResolve<T>>, <T extends Record<string, LiteralSchema>>(schemaEnum: T) => ZodUnion<[
+    {
+        [K in keyof T]: ZodLiteral<T[K]>;
+    }[keyof T]
+]>, (value: unknown) => value is ZodType, <T extends ZodIdiomaticSchema | ZodCatchall>(schema: T, value: unknown) => boolean, <T extends ZodIdiomaticSchema | ZodCatchall>(schema: T, value: unknown) => ParseResult<ZodResolve<T>>, <T extends ZodIdiomaticSchema | ZodCatchall>(schema: T) => SchemaObject> {
     _Type: 'Zod';
     _SchemaCatchall: ZodType;
     _ValidSchemaObject: ZodObject$1<ZodRawShape> | ZodArray<ZodObject$1<ZodRawShape>>;
@@ -124,7 +134,11 @@ declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObjec
      * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
      * @returns {ZodUnion<UnionZodResolve<[T, T, ...T[]]>>} The enum schema.
      */
-    enum_<T extends LiteralSchema>(schemaEnum: Record<string, T>): ZodUnion<UnionZodResolve<[T, T, ...T[]]>>;
+    enum_<T extends Record<string, LiteralSchema>>(schemaEnum: T): ZodUnion<[
+        {
+            [K in keyof T]: ZodLiteral<T[K]>;
+        }[keyof T]
+    ]>;
     /**
      * Checks if a value is a Zod schema.
      * @param {unknown} value - The value to check.
@@ -137,7 +151,7 @@ declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObjec
      * @param {unknown} value - The value to validate.
      * @returns {boolean} True if valid, otherwise false.
      */
-    validate<T extends ZodCatchall>(schema: T, value: unknown): boolean;
+    validate<T extends ZodIdiomaticSchema | ZodCatchall>(schema: T, value: unknown): boolean;
     /**
      * Parses a value to a schema validation.
      *
@@ -145,19 +159,25 @@ declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObjec
      * @param {unknown} value - The value to validate.
      * @returns {ParseResult} - The discrimintated parsed value if successful, the error if unsuccessful.
      */
-    parse<T extends ZodCatchall>(schema: T, value: unknown): ParseResult<ZodResolve<T>>;
+    parse<T extends ZodIdiomaticSchema | ZodCatchall>(schema: T, value: unknown): ParseResult<ZodResolve<T>>;
     /**
      * Convert a schema to an OpenAPI schema object.
      * @param {ZodIdiomaticSchema} schema - The schema to convert.
      * @returns {SchemaObject} The OpenAPI schema object.
      */
-    openapi<T extends ZodIdiomaticSchema>(schema: T): SchemaObject;
+    openapi<T extends ZodIdiomaticSchema | ZodCatchall>(schema: T): SchemaObject;
 }
 
 /**
  * Represents a catch-all Zod schema type.
  */
 type ZodCatchall = ZodTypeAny;
+/**
+ * Represents an outer array schema type for Zod. If the type T is a Zod object, it will return an array schema of T. Otherwise, it returns ZodNever.
+ *
+ * @template T - The type to check and possibly convert to an array schema.
+ */
+type ZodOuterArray<T> = T extends ZodObject<ZodObjectShape> ? ZodArray<T> : ZodNever;
 /**
  * Represents the shape of a Zod object schema.
  */
@@ -177,7 +197,7 @@ type ZodSchemaTranslate<T> = T extends ZodCatchall ? z.infer<T> : ZodNever;
 /**
  * Represents an unboxed Zod object schema where each key can have an idiomatic schema.
  */
-type ZodObjectSchema = UnboxedObjectSchema<ZodSchemaValidator>;
+type UnboxedZodObjectSchema = UnboxedObjectSchema<ZodSchemaValidator>;
 /**
  * Represents an idiomatic schema for Zod which can be an unboxed object schema or a literal schema.
  */
@@ -212,7 +232,7 @@ type UnionZodResolve<T extends ZodUnionContainer> = T extends [
  * @template T - The Zod schema type to resolve.
  * @template Depth - The current depth of the resolution.
  */
-type ZodResolve<T, Depth extends number = 0> = Depth extends 31 ? ZodUnknown : T extends LiteralSchema ? ZodLiteral<T> : T extends ZodType ? T : T extends ZodObjectSchema ? ZodObject<{
+type ZodResolve<T, Depth extends number = 0> = Depth extends 30 ? ZodUnknown : T extends LiteralSchema ? ZodLiteral<T> : T extends ZodType ? T : T extends UnboxedZodObjectSchema ? ZodObject<{
     [K in keyof T]: ZodResolve<T[K], Increment<Depth>>;
 }> : ZodNever;
 
@@ -473,4 +493,4 @@ type Increment<T extends number> = T extends 0 ? 1 : T extends 1 ? 2 : T extends
  */
 type KeyTypes = string | number;
 
-export { type AnySchemaValidator as A, type IdiomaticSchema as I, type KeyTypes as K, type LiteralSchema as L, type ParseError as P, type SchemaValidator as S, type TObject as T, type UnboxedObjectSchema as U, ZodSchemaValidator as Z, type ParseResult as a, type SchemaResolve as b, type SchemaTranslate as c, type Schema as d, type Increment as e, type TIdiomaticSchema as f, type TResolve as g, type TUnionContainer as h, type UnionTResolve as i, type ZodIdiomaticSchema as j, type ZodResolve as k, type ZodUnionContainer as l, type UnionZodResolve as m, type ZodCatchall as n };
+export { type AnySchemaValidator as A, type IdiomaticSchema as I, type KeyTypes as K, type LiteralSchema as L, type ParseError as P, type SchemaValidator as S, type TObject as T, type UnboxedObjectSchema as U, ZodSchemaValidator as Z, type ParseResult as a, type SchemaResolve as b, type SchemaTranslate as c, type Schema as d, type Increment as e, type TIdiomaticSchema as f, type TResolve as g, type TUnionContainer as h, type UnionTResolve as i, type TCatchall as j, type TOuterArray as k, type TObjectShape as l, type TSchemaTranslate as m, type UnboxedTObjectSchema as n, type ZodIdiomaticSchema as o, type ZodResolve as p, type ZodUnionContainer as q, type UnionZodResolve as r, type ZodCatchall as s, type ZodOuterArray as t, type ZodObjectShape as u, type ZodObject as v, type ZodSchemaTranslate as w, type UnboxedZodObjectSchema as x };

package/lib/src/typebox/index.d.mts

@@ -2,9 +2,10 @@ import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
 import { SchemaObject } from 'openapi3-ts/oas31';
 import * as _sinclair_typebox_compiler from '@sinclair/typebox/compiler';
 import { TypeCheck } from '@sinclair/typebox/compiler';
-import { S as SchemaValidator$1, T as TObject, f as TIdiomaticSchema, g as TResolve, h as TUnionContainer, i as UnionTResolve, L as LiteralSchema, a as ParseResult } from '../../schema.types-CA4Aof4g.mjs';
+import { S as SchemaValidator$1, T as TObject, f as TIdiomaticSchema, g as TResolve, h as TUnionContainer, i as UnionTResolve, L as LiteralSchema, j as TCatchall, a as ParseResult } from '../../schema.types-CoFRq_Vn.mjs';
+export { l as TObjectShape, k as TOuterArray, m as TSchemaTranslate, n as UnboxedTObjectSchema } from '../../schema.types-CoFRq_Vn.mjs';
 import * as _sinclair_typebox from '@sinclair/typebox';
-import { TProperties, TOptional, TArray, TUnion, TLiteral, TSchema, TKind } from '@sinclair/typebox';
+import { TProperties, TOptional, TArray, TUnion, TLiteral, TSchema } from '@sinclair/typebox';
 import '@forklaunch/common';
 import 'zod';
 
@@ -12,9 +13,13 @@ import 'zod';
  * Class representing a TypeBox schema definition.
  * @implements {SchemaValidator}
  */
-declare class TypeboxSchemaValidator implements SchemaValidator$1<(<T extends TObject<TProperties>>(schema: T) => TypeCheck<T>), <T extends TIdiomaticSchema>(schema: T) => TResolve<T>, <T extends TIdiomaticSchema>(schema: T) => TOptional<TResolve<T>>, <T extends TIdiomaticSchema>(schema: T) => TArray<TResolve<T>>, <T extends TUnionContainer>(schemas: [...T]) => TUnion<UnionTResolve<T>>, <T extends LiteralSchema>(value: T) => TLiteral<T>, <T extends LiteralSchema>(schemaEnum: Record<string, T>) => TUnion<UnionTResolve<T[]>>, (value: unknown) => value is TSchema, <T extends TIdiomaticSchema>(schema: T, value: unknown) => boolean, <T extends TIdiomaticSchema>(schema: T, value: unknown) => ParseResult<TResolve<T>>, <T extends TIdiomaticSchema>(schema: T) => SchemaObject> {
+declare class TypeboxSchemaValidator implements SchemaValidator$1<(<T extends TObject<TProperties>>(schema: T) => TypeCheck<T>), <T extends TIdiomaticSchema>(schema: T) => TResolve<T>, <T extends TIdiomaticSchema>(schema: T) => TOptional<TResolve<T>>, <T extends TIdiomaticSchema>(schema: T) => TArray<TResolve<T>>, <T extends TUnionContainer>(schemas: [...T]) => TUnion<UnionTResolve<T>>, <T extends LiteralSchema>(value: T) => TLiteral<T>, <T extends Record<string, LiteralSchema>>(schemaEnum: T) => TUnion<[
+    {
+        [K in keyof T]: TLiteral<T[K]>;
+    }[keyof T]
+]>, (value: unknown) => value is TSchema, <T extends TIdiomaticSchema | TCatchall>(schema: T, value: unknown) => boolean, <T extends TIdiomaticSchema | TCatchall>(schema: T, value: unknown) => ParseResult<TResolve<T>>, <T extends TIdiomaticSchema | TCatchall>(schema: T) => SchemaObject> {
     _Type: 'TypeBox';
-    _SchemaCatchall: TKind;
+    _SchemaCatchall: TSchema;
     _ValidSchemaObject: TObject<TProperties> | TArray<TObject<TProperties>>;
     string: _sinclair_typebox.TString;
     uuid: _sinclair_typebox.TString;
@@ -81,7 +86,11 @@ declare class TypeboxSchemaValidator implements SchemaValidator$1<(<T extends TO
      * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
      * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
      */
-    enum_<T extends LiteralSchema>(schemaEnum: Record<string, T>): TUnion<UnionTResolve<T[]>>;
+    enum_<T extends Record<string, LiteralSchema>>(schemaEnum: T): TUnion<[
+        {
+            [K in keyof T]: TLiteral<T[K]>;
+        }[keyof T]
+    ]>;
     /**
      * Check if a value is a TypeBox object schema.
      * @param {unknown} value - The value to check.
@@ -192,7 +201,7 @@ declare const literal: <T extends LiteralSchema>(value: T) => _sinclair_typebox.
 /**
  * Defines an enum for a valid schema.
  */
-declare const enum_: <T extends LiteralSchema>(schemaEnum: Record<string, T>) => _sinclair_typebox.TUnion<UnionTResolve<T[]>>;
+declare const enum_: <T extends Record<string, LiteralSchema>>(schemaEnum: T) => _sinclair_typebox.TUnion<[{ [K in keyof T]: _sinclair_typebox.TLiteral<T[K]>; }[keyof T]]>;
 /**
  * Checks if a value is a TypeBox schema.
  */
@@ -210,4 +219,4 @@ declare const parse: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(sc
  */
 declare const openapi: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(schema: T) => openapi3_ts_oas31.SchemaObject;
 
-export { SchemaValidator, TypeboxSchemaValidator, any, array, bigint, boolean, date, email, enum_, isSchema, literal, never, nullish, number, openapi, optional, parse, schemify, string, symbol, union, unknown, uri, uuid, validate };
+export { SchemaValidator, TCatchall, TIdiomaticSchema, TObject, TResolve, TUnionContainer, TypeboxSchemaValidator, UnionTResolve, any, array, bigint, boolean, date, email, enum_, isSchema, literal, never, nullish, number, openapi, optional, parse, schemify, string, symbol, union, unknown, uri, uuid, validate };

package/lib/src/typebox/index.d.ts

@@ -2,9 +2,10 @@ import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
 import { SchemaObject } from 'openapi3-ts/oas31';
 import * as _sinclair_typebox_compiler from '@sinclair/typebox/compiler';
 import { TypeCheck } from '@sinclair/typebox/compiler';
-import { S as SchemaValidator$1, T as TObject, f as TIdiomaticSchema, g as TResolve, h as TUnionContainer, i as UnionTResolve, L as LiteralSchema, a as ParseResult } from '../../schema.types-CA4Aof4g.js';
+import { S as SchemaValidator$1, T as TObject, f as TIdiomaticSchema, g as TResolve, h as TUnionContainer, i as UnionTResolve, L as LiteralSchema, j as TCatchall, a as ParseResult } from '../../schema.types-CoFRq_Vn.js';
+export { l as TObjectShape, k as TOuterArray, m as TSchemaTranslate, n as UnboxedTObjectSchema } from '../../schema.types-CoFRq_Vn.js';
 import * as _sinclair_typebox from '@sinclair/typebox';
-import { TProperties, TOptional, TArray, TUnion, TLiteral, TSchema, TKind } from '@sinclair/typebox';
+import { TProperties, TOptional, TArray, TUnion, TLiteral, TSchema } from '@sinclair/typebox';
 import '@forklaunch/common';
 import 'zod';
 
@@ -12,9 +13,13 @@ import 'zod';
  * Class representing a TypeBox schema definition.
  * @implements {SchemaValidator}
  */
-declare class TypeboxSchemaValidator implements SchemaValidator$1<(<T extends TObject<TProperties>>(schema: T) => TypeCheck<T>), <T extends TIdiomaticSchema>(schema: T) => TResolve<T>, <T extends TIdiomaticSchema>(schema: T) => TOptional<TResolve<T>>, <T extends TIdiomaticSchema>(schema: T) => TArray<TResolve<T>>, <T extends TUnionContainer>(schemas: [...T]) => TUnion<UnionTResolve<T>>, <T extends LiteralSchema>(value: T) => TLiteral<T>, <T extends LiteralSchema>(schemaEnum: Record<string, T>) => TUnion<UnionTResolve<T[]>>, (value: unknown) => value is TSchema, <T extends TIdiomaticSchema>(schema: T, value: unknown) => boolean, <T extends TIdiomaticSchema>(schema: T, value: unknown) => ParseResult<TResolve<T>>, <T extends TIdiomaticSchema>(schema: T) => SchemaObject> {
+declare class TypeboxSchemaValidator implements SchemaValidator$1<(<T extends TObject<TProperties>>(schema: T) => TypeCheck<T>), <T extends TIdiomaticSchema>(schema: T) => TResolve<T>, <T extends TIdiomaticSchema>(schema: T) => TOptional<TResolve<T>>, <T extends TIdiomaticSchema>(schema: T) => TArray<TResolve<T>>, <T extends TUnionContainer>(schemas: [...T]) => TUnion<UnionTResolve<T>>, <T extends LiteralSchema>(value: T) => TLiteral<T>, <T extends Record<string, LiteralSchema>>(schemaEnum: T) => TUnion<[
+    {
+        [K in keyof T]: TLiteral<T[K]>;
+    }[keyof T]
+]>, (value: unknown) => value is TSchema, <T extends TIdiomaticSchema | TCatchall>(schema: T, value: unknown) => boolean, <T extends TIdiomaticSchema | TCatchall>(schema: T, value: unknown) => ParseResult<TResolve<T>>, <T extends TIdiomaticSchema | TCatchall>(schema: T) => SchemaObject> {
     _Type: 'TypeBox';
-    _SchemaCatchall: TKind;
+    _SchemaCatchall: TSchema;
     _ValidSchemaObject: TObject<TProperties> | TArray<TObject<TProperties>>;
     string: _sinclair_typebox.TString;
     uuid: _sinclair_typebox.TString;
@@ -81,7 +86,11 @@ declare class TypeboxSchemaValidator implements SchemaValidator$1<(<T extends TO
      * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
      * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
      */
-    enum_<T extends LiteralSchema>(schemaEnum: Record<string, T>): TUnion<UnionTResolve<T[]>>;
+    enum_<T extends Record<string, LiteralSchema>>(schemaEnum: T): TUnion<[
+        {
+            [K in keyof T]: TLiteral<T[K]>;
+        }[keyof T]
+    ]>;
     /**
      * Check if a value is a TypeBox object schema.
      * @param {unknown} value - The value to check.
@@ -192,7 +201,7 @@ declare const literal: <T extends LiteralSchema>(value: T) => _sinclair_typebox.
 /**
  * Defines an enum for a valid schema.
  */
-declare const enum_: <T extends LiteralSchema>(schemaEnum: Record<string, T>) => _sinclair_typebox.TUnion<UnionTResolve<T[]>>;
+declare const enum_: <T extends Record<string, LiteralSchema>>(schemaEnum: T) => _sinclair_typebox.TUnion<[{ [K in keyof T]: _sinclair_typebox.TLiteral<T[K]>; }[keyof T]]>;
 /**
  * Checks if a value is a TypeBox schema.
  */
@@ -210,4 +219,4 @@ declare const parse: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(sc
  */
 declare const openapi: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(schema: T) => openapi3_ts_oas31.SchemaObject;
 
-export { SchemaValidator, TypeboxSchemaValidator, any, array, bigint, boolean, date, email, enum_, isSchema, literal, never, nullish, number, openapi, optional, parse, schemify, string, symbol, union, unknown, uri, uuid, validate };
+export { SchemaValidator, TCatchall, TIdiomaticSchema, TObject, TResolve, TUnionContainer, TypeboxSchemaValidator, UnionTResolve, any, array, bigint, boolean, date, email, enum_, isSchema, literal, never, nullish, number, openapi, optional, parse, schemify, string, symbol, union, unknown, uri, uuid, validate };

package/lib/src/typebox/index.js

@@ -283,7 +283,9 @@ var TypeboxSchemaValidator = class {
    * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
    */
   enum_(schemaEnum) {
-    return this.union(Object.values(schemaEnum));
+    return this.union(
+      Object.values(schemaEnum).map((value) => this.literal(value))
+    );
   }
   /**
    * Check if a value is a TypeBox object schema.
@@ -332,15 +334,42 @@ var TypeboxSchemaValidator = class {
         errors = Array.from(import_value.Value.Errors(schemified, value));
       }
     }
+    errors.forEach((error) => {
+      if (error.type === import_errors.ValueErrorType.Union && error.schema.errorType === "any of") {
+        error.errors.forEach((e, idx) => {
+          console.log({
+            p: [`Union Schema Variant ${idx}`, error.path],
+            message: Array.from(e)
+          });
+        });
+      }
+    });
     return errors != null && errors.length === 0 ? {
       ok: true,
       value: conversion
     } : {
       ok: false,
-      errors: errors.map((error) => ({
-        path: error.path.split("/").slice(1),
-        message: error.message
-      }))
+      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
+            }
+          ];
+        }
+      })
     };
   }
   /**

package/lib/src/typebox/index.mjs

@@ -242,7 +242,9 @@ var TypeboxSchemaValidator = class {
    * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
    */
   enum_(schemaEnum) {
-    return this.union(Object.values(schemaEnum));
+    return this.union(
+      Object.values(schemaEnum).map((value) => this.literal(value))
+    );
   }
   /**
    * Check if a value is a TypeBox object schema.
@@ -291,15 +293,42 @@ var TypeboxSchemaValidator = class {
         errors = Array.from(Value.Errors(schemified, value));
       }
     }
+    errors.forEach((error) => {
+      if (error.type === ValueErrorType.Union && error.schema.errorType === "any of") {
+        error.errors.forEach((e, idx) => {
+          console.log({
+            p: [`Union Schema Variant ${idx}`, error.path],
+            message: Array.from(e)
+          });
+        });
+      }
+    });
     return errors != null && errors.length === 0 ? {
       ok: true,
       value: conversion
     } : {
       ok: false,
-      errors: errors.map((error) => ({
-        path: error.path.split("/").slice(1),
-        message: error.message
-      }))
+      errors: errors.flatMap((error) => {
+        if (error.type === ValueErrorType.Union && error.schema.errorType.includes("any of")) {
+          return error.errors.flatMap(
+            (e, idx) => Array.from(e).map((e2) => ({
+              path: [
+                `Union Schema Variant ${idx}`,
+                ...error.path.split("/").slice(1),
+                ...e2.path.split("/").slice(1)
+              ],
+              message: e2.message
+            }))
+          );
+        } else {
+          return [
+            {
+              path: error.path.split("/").slice(1),
+              message: error.message
+            }
+          ];
+        }
+      })
     };
   }
   /**

package/lib/src/zod/index.d.mts

@@ -1,5 +1,6 @@
 import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
-import { Z as ZodSchemaValidator, j as ZodIdiomaticSchema, k as ZodResolve, l as ZodUnionContainer, m as UnionZodResolve, L as LiteralSchema, n as ZodCatchall, a as ParseResult } from '../../schema.types-CA4Aof4g.mjs';
+import { Z as ZodSchemaValidator, o as ZodIdiomaticSchema, p as ZodResolve, q as ZodUnionContainer, r as UnionZodResolve, L as LiteralSchema, s as ZodCatchall, a as ParseResult } from '../../schema.types-CoFRq_Vn.mjs';
+export { x as UnboxedZodObjectSchema, v as ZodObject, u as ZodObjectShape, t as ZodOuterArray, w as ZodSchemaTranslate } from '../../schema.types-CoFRq_Vn.mjs';
 import * as zod from 'zod';
 import '@forklaunch/common';
 import '@sinclair/typebox';
@@ -85,7 +86,7 @@ declare const literal: <T extends LiteralSchema>(value: T) => zod.ZodLiteral<Zod
 /**
  * Defines an enum for a valid schema.
  */
-declare const enum_: <T extends LiteralSchema>(schemaEnum: Record<string, T>) => zod.ZodUnion<UnionZodResolve<[T, T, ...T[]]>>;
+declare const enum_: <T extends Record<string, LiteralSchema>>(schemaEnum: T) => zod.ZodUnion<[{ [K in keyof T]: zod.ZodLiteral<T[K]>; }[keyof T]]>;
 /**
  * Checks if a value is a Zod schema.
  */
@@ -93,14 +94,14 @@ declare const isSchema: (value: unknown) => value is zod.ZodSchema;
 /**
  * Validates a value against a valid schema.
  */
-declare const validate: <T extends ZodCatchall>(schema: T, value: unknown) => boolean;
+declare const validate: <T extends ZodIdiomaticSchema | ZodCatchall>(schema: T, value: unknown) => boolean;
 /**
  * Parses a value to be conformant to a particular schema.
  */
-declare const parse: <T extends ZodCatchall>(schema: T, value: unknown) => ParseResult<ZodResolve<T>>;
+declare const parse: <T extends ZodIdiomaticSchema | ZodCatchall>(schema: T, value: unknown) => ParseResult<ZodResolve<T>>;
 /**
  * Generates an OpenAPI schema object from a valid schema.
  */
-declare const openapi: <T extends ZodIdiomaticSchema>(schema: T) => openapi3_ts_oas31.SchemaObject;
+declare const openapi: <T extends ZodIdiomaticSchema | ZodCatchall>(schema: T) => openapi3_ts_oas31.SchemaObject;
 
-export { SchemaValidator, ZodSchemaValidator, any, array, bigint, boolean, date, email, enum_, isSchema, literal, never, nullish, number, openapi, optional, parse, schemify, string, symbol, union, unknown, uri, uuid, validate };
+export { SchemaValidator, UnionZodResolve, ZodCatchall, ZodIdiomaticSchema, ZodResolve, ZodSchemaValidator, ZodUnionContainer, any, array, bigint, boolean, date, email, enum_, isSchema, literal, never, nullish, number, openapi, optional, parse, schemify, string, symbol, union, unknown, uri, uuid, validate };

package/lib/src/zod/index.d.ts

@@ -1,5 +1,6 @@
 import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
-import { Z as ZodSchemaValidator, j as ZodIdiomaticSchema, k as ZodResolve, l as ZodUnionContainer, m as UnionZodResolve, L as LiteralSchema, n as ZodCatchall, a as ParseResult } from '../../schema.types-CA4Aof4g.js';
+import { Z as ZodSchemaValidator, o as ZodIdiomaticSchema, p as ZodResolve, q as ZodUnionContainer, r as UnionZodResolve, L as LiteralSchema, s as ZodCatchall, a as ParseResult } from '../../schema.types-CoFRq_Vn.js';
+export { x as UnboxedZodObjectSchema, v as ZodObject, u as ZodObjectShape, t as ZodOuterArray, w as ZodSchemaTranslate } from '../../schema.types-CoFRq_Vn.js';
 import * as zod from 'zod';
 import '@forklaunch/common';
 import '@sinclair/typebox';
@@ -85,7 +86,7 @@ declare const literal: <T extends LiteralSchema>(value: T) => zod.ZodLiteral<Zod
 /**
  * Defines an enum for a valid schema.
  */
-declare const enum_: <T extends LiteralSchema>(schemaEnum: Record<string, T>) => zod.ZodUnion<UnionZodResolve<[T, T, ...T[]]>>;
+declare const enum_: <T extends Record<string, LiteralSchema>>(schemaEnum: T) => zod.ZodUnion<[{ [K in keyof T]: zod.ZodLiteral<T[K]>; }[keyof T]]>;
 /**
  * Checks if a value is a Zod schema.
  */
@@ -93,14 +94,14 @@ declare const isSchema: (value: unknown) => value is zod.ZodSchema;
 /**
  * Validates a value against a valid schema.
  */
-declare const validate: <T extends ZodCatchall>(schema: T, value: unknown) => boolean;
+declare const validate: <T extends ZodIdiomaticSchema | ZodCatchall>(schema: T, value: unknown) => boolean;
 /**
  * Parses a value to be conformant to a particular schema.
  */
-declare const parse: <T extends ZodCatchall>(schema: T, value: unknown) => ParseResult<ZodResolve<T>>;
+declare const parse: <T extends ZodIdiomaticSchema | ZodCatchall>(schema: T, value: unknown) => ParseResult<ZodResolve<T>>;
 /**
  * Generates an OpenAPI schema object from a valid schema.
  */
-declare const openapi: <T extends ZodIdiomaticSchema>(schema: T) => openapi3_ts_oas31.SchemaObject;
+declare const openapi: <T extends ZodIdiomaticSchema | ZodCatchall>(schema: T) => openapi3_ts_oas31.SchemaObject;
 
-export { SchemaValidator, ZodSchemaValidator, any, array, bigint, boolean, date, email, enum_, isSchema, literal, never, nullish, number, openapi, optional, parse, schemify, string, symbol, union, unknown, uri, uuid, validate };
+export { SchemaValidator, UnionZodResolve, ZodCatchall, ZodIdiomaticSchema, ZodResolve, ZodSchemaValidator, ZodUnionContainer, any, array, bigint, boolean, date, email, enum_, isSchema, literal, never, nullish, number, openapi, optional, parse, schemify, string, symbol, union, unknown, uri, uuid, validate };

package/lib/src/zod/index.js

@@ -75,7 +75,7 @@ var ZodSchemaValidator = class {
   boolean = import_zod.z.preprocess((val) => {
     if (typeof val === "string") {
       if (val.toLowerCase() === "true") return true;
-      return false;
+      if (val.toLowerCase() === "false") return false;
     }
     return val;
   }, import_zod.z.boolean());
@@ -176,7 +176,9 @@ var ZodSchemaValidator = class {
    * @returns {ZodUnion<UnionZodResolve<[T, T, ...T[]]>>} The enum schema.
    */
   enum_(schemaEnum) {
-    return this.union(Object.values(schemaEnum));
+    return this.union(
+      Object.values(schemaEnum)
+    );
   }
   /**
    * Checks if a value is a Zod schema.
@@ -193,7 +195,8 @@ var ZodSchemaValidator = class {
    * @returns {boolean} True if valid, otherwise false.
    */
   validate(schema, value) {
-    return schema.safeParse(value).success;
+    const resolvedSchema = schema instanceof import_zod.ZodType ? schema : this.schemify(schema);
+    return resolvedSchema.safeParse(value).success;
   }
   /**
    * Parses a value to a schema validation.
@@ -203,13 +206,32 @@ var ZodSchemaValidator = class {
    * @returns {ParseResult} - The discrimintated parsed value if successful, the error if unsuccessful.
    */
   parse(schema, value) {
-    const result = schema.safeParse(value);
+    const resolvedSchema = schema instanceof import_zod.ZodType ? schema : this.schemify(schema);
+    const result = resolvedSchema.safeParse(value);
     return result.success ? { ok: true, value: result.data } : {
       ok: false,
-      errors: result.error.errors.map((error) => ({
-        path: error.path.map((p) => p.toString()),
-        message: error.message
-      }))
+      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
+              }
+            ];
+        }
+      })
     };
   }
   /**
@@ -218,7 +240,9 @@ var ZodSchemaValidator = class {
    * @returns {SchemaObject} The OpenAPI schema object.
    */
   openapi(schema) {
-    return (0, import_zod_openapi.generateSchema)(this.schemify(schema));
+    return (0, import_zod_openapi.generateSchema)(
+      schema instanceof import_zod.ZodType ? schema : this.schemify(schema)
+    );
   }
 };
 

package/lib/src/zod/index.mjs

@@ -29,7 +29,7 @@ var ZodSchemaValidator = class {
   boolean = z.preprocess((val) => {
     if (typeof val === "string") {
       if (val.toLowerCase() === "true") return true;
-      return false;
+      if (val.toLowerCase() === "false") return false;
     }
     return val;
   }, z.boolean());
@@ -130,7 +130,9 @@ var ZodSchemaValidator = class {
    * @returns {ZodUnion<UnionZodResolve<[T, T, ...T[]]>>} The enum schema.
    */
   enum_(schemaEnum) {
-    return this.union(Object.values(schemaEnum));
+    return this.union(
+      Object.values(schemaEnum)
+    );
   }
   /**
    * Checks if a value is a Zod schema.
@@ -147,7 +149,8 @@ var ZodSchemaValidator = class {
    * @returns {boolean} True if valid, otherwise false.
    */
   validate(schema, value) {
-    return schema.safeParse(value).success;
+    const resolvedSchema = schema instanceof ZodType ? schema : this.schemify(schema);
+    return resolvedSchema.safeParse(value).success;
   }
   /**
    * Parses a value to a schema validation.
@@ -157,13 +160,32 @@ var ZodSchemaValidator = class {
    * @returns {ParseResult} - The discrimintated parsed value if successful, the error if unsuccessful.
    */
   parse(schema, value) {
-    const result = schema.safeParse(value);
+    const resolvedSchema = schema instanceof ZodType ? schema : this.schemify(schema);
+    const result = resolvedSchema.safeParse(value);
     return result.success ? { ok: true, value: result.data } : {
       ok: false,
-      errors: result.error.errors.map((error) => ({
-        path: error.path.map((p) => p.toString()),
-        message: error.message
-      }))
+      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
+              }
+            ];
+        }
+      })
     };
   }
   /**
@@ -172,7 +194,9 @@ var ZodSchemaValidator = class {
    * @returns {SchemaObject} The OpenAPI schema object.
    */
   openapi(schema) {
-    return generateSchema(this.schemify(schema));
+    return generateSchema(
+      schema instanceof ZodType ? schema : this.schemify(schema)
+    );
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forklaunch/validator",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "description": "Schema validator for ForkLaunch components.",
   "homepage": "https://github.com/forklaunch/forklaunch-js#readme",
   "bugs": {
@@ -44,41 +44,42 @@
       "default": "./lib/src/zod/types/schema.types.js"
     },
     "./tests/mockSchemaValidator": {
-      "types": "./lib/tests/utils/mockSchemaValidator.d.ts",
-      "import": "./lib/tests/utils/mockSchemaValidator.mjs",
-      "require": "./lib/tests/utils/mockSchemaValidator.js",
-      "default": "./lib/tests/utils/mockSchemaValidator.js"
+      "types": "./lib/__test__/utils/mockSchemaValidator.d.ts",
+      "import": "./lib/__test__/utils/mockSchemaValidator.mjs",
+      "require": "./lib/__test__/utils/mockSchemaValidator.js",
+      "default": "./lib/__test__/utils/mockSchemaValidator.js"
     }
   },
   "types": "lib/index.d.ts",
   "directories": {
-    "test": "tests"
+    "test": "__test__"
   },
   "files": [
     "lib"
   ],
   "dependencies": {
     "@anatine/zod-openapi": "^2.2.7",
-    "@sinclair/typebox": "^0.34.28",
+    "@sinclair/typebox": "^0.34.33",
     "zod": "^3.24.2",
-    "@forklaunch/common": "0.2.3"
+    "@forklaunch/common": "0.2.5"
   },
   "devDependencies": {
-    "@eslint/js": "^9.22.0",
+    "@eslint/js": "^9.23.0",
     "@types/jest": "^29.5.14",
-    "@vitest/coverage-v8": "^3.0.8",
+    "@vitest/coverage-v8": "^3.1.1",
     "eslint-config-prettier": "^10.1.1",
-    "eslint-plugin-prettier": "^5.2.3",
+    "eslint-plugin-prettier": "^5.2.6",
     "globals": "^16.0.0",
     "jest": "^29.7.0",
     "openapi3-ts": "^4.4.0",
-    "ts-jest": "^29.2.6",
+    "ts-jest": "^29.3.1",
     "ts-node": "^10.9.2",
     "tsup": "^8.4.0",
-    "typescript-eslint": "^8.26.0"
+    "typedoc": "^0.28.1",
+    "typescript-eslint": "^8.29.0"
   },
   "scripts": {
-    "build": "tsc --noEmit && tsup index.ts src/typebox/index.ts src/zod/index.ts tests/utils/mockSchemaValidator.ts --format cjs,esm --no-splitting --tsconfig tsconfig.json --outDir lib --dts --clean",
+    "build": "tsc --noEmit && tsup index.ts src/typebox/index.ts src/zod/index.ts __test__/utils/mockSchemaValidator.ts --format cjs,esm --no-splitting --tsconfig tsconfig.json --outDir lib --dts --clean",
     "check": "depcheck",
     "clean": "rm -rf lib pnpm.lock.yaml node_modules",
     "docs": "typedoc --out docs *",