@forklaunch/validator 0.4.11 → 0.4.12

package/lib/__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-BA3PeCI5.mjs';
+import { S as SchemaValidator, L as LiteralSchema, a as ParseResult } from '../../schema.types-LkSEBFTv.mjs';
 import '@forklaunch/common';
 import '@sinclair/typebox';
 import '@sinclair/typebox/compiler';

package/lib/__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-BA3PeCI5.js';
+import { S as SchemaValidator, L as LiteralSchema, a as ParseResult } from '../../schema.types-LkSEBFTv.js';
 import '@forklaunch/common';
 import '@sinclair/typebox';
 import '@sinclair/typebox/compiler';

package/lib/index.d.mts

@@ -1,5 +1,5 @@
-import { P as ParseError } from './schema.types-BA3PeCI5.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-BA3PeCI5.mjs';
+import { P as ParseError } from './schema.types-LkSEBFTv.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-LkSEBFTv.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-BA3PeCI5.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-BA3PeCI5.js';
+import { P as ParseError } from './schema.types-LkSEBFTv.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-LkSEBFTv.js';
 import '@forklaunch/common';
 import 'openapi3-ts/oas31';
 import '@sinclair/typebox';

package/lib/{schema.types-BA3PeCI5.d.mts → schema.types-LkSEBFTv.d.mts}

@@ -1,9 +1,122 @@
 import { Prettify } from '@forklaunch/common';
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { TUnknown, TLiteral, TSchema, TKind, TProperties, TObject as TObject$1, TNever, StaticDecode, TArray } from '@sinclair/typebox';
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { TProperties, TOptional, TArray, TUnion, TLiteral, TSchema, TUnknown, TKind, TObject as TObject$1, TNever, StaticDecode } 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';
 
+/**
+ * Class representing a TypeBox schema definition.
+ * @implements {SchemaValidator}
+ */
+declare class TypeboxSchemaValidator implements SchemaValidator<(<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: TCatchall;
+    _ValidSchemaObject: TObject<TProperties> | TArray<TObject<TProperties>>;
+    string: _sinclair_typebox.TString;
+    uuid: _sinclair_typebox.TString;
+    uri: _sinclair_typebox.TString;
+    email: _sinclair_typebox.TString;
+    number: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull, _sinclair_typebox.TDate, _sinclair_typebox.TBigInt]>, number>;
+    bigint: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TBigInt, _sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TDate]>, bigint>;
+    boolean: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TBoolean, _sinclair_typebox.TString]>, boolean>;
+    date: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TDate, _sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull]>, Date>;
+    symbol: _sinclair_typebox.TSymbol;
+    nullish: TUnion<[_sinclair_typebox.TVoid, _sinclair_typebox.TNull, _sinclair_typebox.TUndefined]>;
+    any: _sinclair_typebox.TAny;
+    unknown: _sinclair_typebox.TUnknown;
+    never: _sinclair_typebox.TNever;
+    /**
+     * 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.
+     */
+    private errorType;
+    /**
+     * Compiles schema if this exists, for optimal performance.
+     *
+     * @param {TObject<TProperties>} schema - The schema to compile.
+     * @returns {TypeCheck<T>} - The compiled schema.
+     */
+    compile<T extends TObject<TProperties>>(schema: T): TypeCheck<T>;
+    /**
+     * Convert a schema to a TypeBox schema.
+     * @param {TIdiomaticSchema} schema - The schema to convert.
+     * @returns {TResolve<T>} The resolved schema.
+     */
+    schemify<T extends TIdiomaticSchema>(schema: T): TResolve<T>;
+    /**
+     * Make a schema optional.
+     * @param {TIdiomaticSchema} schema - The schema to make optional.
+     * @returns {TOptional<TResolve<T>>} The optional schema.
+     */
+    optional<T extends TIdiomaticSchema>(schema: T): TOptional<TResolve<T>>;
+    /**
+     * Create an array schema.
+     * @param {TIdiomaticSchema} schema - The schema to use for array items.
+     * @returns {TArray<TResolve<T>>} The array schema.
+     */
+    array<T extends TIdiomaticSchema>(schema: T): TArray<TResolve<T>>;
+    /**
+     * Create a union schema.
+     * @param {TUnionContainer} schemas - The schemas to union.
+     * @returns {TUnion<UnionTResolve<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<T extends TUnionContainer>(schemas: [...T]): TUnion<UnionTResolve<T>>;
+    /**
+     * Create a literal schema.
+     * @param {LiteralSchema} value - The literal value.
+     * @returns {TLiteral<T>} The literal schema.
+     */
+    literal<T extends LiteralSchema>(value: T): TLiteral<T>;
+    /**
+     * Create an enum schema.
+     * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
+     * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
+     */
+    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.
+     * @returns {boolean} True if the value is a TypeBox object schema.
+     */
+    isSchema(value: unknown): value is TSchema;
+    /**
+     * 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<T extends TIdiomaticSchema | TCatchall>(schema: T | TypeCheck<TResolve<T>>, value: unknown): boolean;
+    /**
+     * 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<T extends TIdiomaticSchema | TCatchall>(schema: T | TypeCheck<TResolve<T>>, value: unknown): ParseResult<TResolve<T>>;
+    /**
+     * Convert a schema to an OpenAPI schema object.
+     * @param {TIdiomaticSchema | TCatchall} schema - The schema to convert.
+     * @returns {SchemaObject} The OpenAPI schema object.
+     */
+    openapi<T extends TIdiomaticSchema | TCatchall>(schema: T): SchemaObject;
+}
+
 /**
  * Represents a catch-all schema type.
  */
@@ -29,7 +142,7 @@ type TObject<T> = T extends TObjectShape ? TObject$1<T> : TNever;
  *
  * @template T - The schema type to translate.
  */
-type TSchemaTranslate<T> = T extends TCatchall ? StaticDecode<T> : TNever;
+type TSchemaTranslate<T> = T extends TSchema ? StaticDecode<T> : TNever;
 /**
  * Represents an unboxed object schema where each key can have an idiomatic schema.
  */
@@ -39,7 +152,7 @@ type UnboxedTObjectSchema = {
 /**
  * Represents an idiomatic schema which can be an unboxed object schema or a literal schema.
  */
-type TIdiomaticSchema = UnboxedTObjectSchema | LiteralSchema;
+type TIdiomaticSchema = IdiomaticSchema<TypeboxSchemaValidator>;
 /**
  * Represents a container for a union of idiomatic schemas.
  */
@@ -49,16 +162,19 @@ type TUnionContainer = [...TIdiomaticSchema[]];
  *
  * @template T - The union container to resolve.
  */
-type UnionTResolve<T extends TUnionContainer> = T extends (infer UnionTypes)[] ? [TResolve<UnionTypes>] : TNever;
+type UnionTResolve<T extends TUnionContainer, Acc extends TIdiomaticSchema[] = []> = T extends [
+    infer Head extends TIdiomaticSchema,
+    ...infer Tail extends TUnionContainer
+] ? UnionTResolve<Tail, [...Acc, TResolve<Head>]> : T extends [] ? Acc : TNever[];
 /**
  * Resolves a schema type T to its resolved type. The depth is limited to 12 to prevent infinite recursion, due to StaticDecode limitations.
  *
  * @template T - The schema type to resolve.
  * @template Depth - The current depth of the resolution.
  */
-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 TypeCheck<infer Type> ? TResolve<Type, Increment<Depth>> : T extends UnboxedTObjectSchema ? TObject<{
+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 UnboxedTObjectSchema ? TObject<{
     [K in keyof T]: TResolve<T[K], Increment<Depth>>;
-}> : TNever;
+}> extends infer R ? R : TNever : T extends TypeCheck<infer Type> ? TResolve<Type, Increment<Depth>> : TNever;
 
 /**
  * This module provides a Zod-based schema definition.
@@ -227,14 +343,14 @@ type UnionZodResolve<T extends ZodUnionContainer> = T extends [
     }
 ] : [ZodNever, ZodNever];
 /**
- * Resolves a Zod schema type T to its resolved type. The depth is limited to 31 to prevent infinite recursion.
+ * Resolves a Zod schema type T to its resolved type. The depth is limited to 29 to prevent infinite recursion.
  *
  * @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 30 ? ZodUnknown : T extends LiteralSchema ? ZodLiteral<T> : T extends ZodType ? T : T extends UnboxedZodObjectSchema ? ZodObject<{
+type ZodResolve<T, Depth extends number = 0> = Depth extends 29 ? ZodUnknown : T extends LiteralSchema ? ZodLiteral<T> : T extends ZodType ? T : T extends UnboxedZodObjectSchema ? ZodObject<{
     [K in keyof T]: ZodResolve<T[K], Increment<Depth>>;
-}> : ZodNever;
+}> extends infer R ? R : ZodNever : ZodNever;
 
 /**
  * Represents an error with a path and message.
@@ -493,4 +609,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 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 };
+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, TypeboxSchemaValidator 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 TObject as m, type TSchemaTranslate as n, type UnboxedTObjectSchema as o, type ZodIdiomaticSchema as p, type ZodResolve as q, type ZodUnionContainer as r, type UnionZodResolve as s, type ZodCatchall as t, type ZodOuterArray as u, type ZodObjectShape as v, type ZodObject as w, type ZodSchemaTranslate as x, type UnboxedZodObjectSchema as y };

package/lib/{schema.types-BA3PeCI5.d.ts → schema.types-LkSEBFTv.d.ts}

@@ -1,9 +1,122 @@
 import { Prettify } from '@forklaunch/common';
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { TUnknown, TLiteral, TSchema, TKind, TProperties, TObject as TObject$1, TNever, StaticDecode, TArray } from '@sinclair/typebox';
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { TProperties, TOptional, TArray, TUnion, TLiteral, TSchema, TUnknown, TKind, TObject as TObject$1, TNever, StaticDecode } 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';
 
+/**
+ * Class representing a TypeBox schema definition.
+ * @implements {SchemaValidator}
+ */
+declare class TypeboxSchemaValidator implements SchemaValidator<(<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: TCatchall;
+    _ValidSchemaObject: TObject<TProperties> | TArray<TObject<TProperties>>;
+    string: _sinclair_typebox.TString;
+    uuid: _sinclair_typebox.TString;
+    uri: _sinclair_typebox.TString;
+    email: _sinclair_typebox.TString;
+    number: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull, _sinclair_typebox.TDate, _sinclair_typebox.TBigInt]>, number>;
+    bigint: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TBigInt, _sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TDate]>, bigint>;
+    boolean: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TBoolean, _sinclair_typebox.TString]>, boolean>;
+    date: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TDate, _sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull]>, Date>;
+    symbol: _sinclair_typebox.TSymbol;
+    nullish: TUnion<[_sinclair_typebox.TVoid, _sinclair_typebox.TNull, _sinclair_typebox.TUndefined]>;
+    any: _sinclair_typebox.TAny;
+    unknown: _sinclair_typebox.TUnknown;
+    never: _sinclair_typebox.TNever;
+    /**
+     * 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.
+     */
+    private errorType;
+    /**
+     * Compiles schema if this exists, for optimal performance.
+     *
+     * @param {TObject<TProperties>} schema - The schema to compile.
+     * @returns {TypeCheck<T>} - The compiled schema.
+     */
+    compile<T extends TObject<TProperties>>(schema: T): TypeCheck<T>;
+    /**
+     * Convert a schema to a TypeBox schema.
+     * @param {TIdiomaticSchema} schema - The schema to convert.
+     * @returns {TResolve<T>} The resolved schema.
+     */
+    schemify<T extends TIdiomaticSchema>(schema: T): TResolve<T>;
+    /**
+     * Make a schema optional.
+     * @param {TIdiomaticSchema} schema - The schema to make optional.
+     * @returns {TOptional<TResolve<T>>} The optional schema.
+     */
+    optional<T extends TIdiomaticSchema>(schema: T): TOptional<TResolve<T>>;
+    /**
+     * Create an array schema.
+     * @param {TIdiomaticSchema} schema - The schema to use for array items.
+     * @returns {TArray<TResolve<T>>} The array schema.
+     */
+    array<T extends TIdiomaticSchema>(schema: T): TArray<TResolve<T>>;
+    /**
+     * Create a union schema.
+     * @param {TUnionContainer} schemas - The schemas to union.
+     * @returns {TUnion<UnionTResolve<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<T extends TUnionContainer>(schemas: [...T]): TUnion<UnionTResolve<T>>;
+    /**
+     * Create a literal schema.
+     * @param {LiteralSchema} value - The literal value.
+     * @returns {TLiteral<T>} The literal schema.
+     */
+    literal<T extends LiteralSchema>(value: T): TLiteral<T>;
+    /**
+     * Create an enum schema.
+     * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
+     * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
+     */
+    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.
+     * @returns {boolean} True if the value is a TypeBox object schema.
+     */
+    isSchema(value: unknown): value is TSchema;
+    /**
+     * 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<T extends TIdiomaticSchema | TCatchall>(schema: T | TypeCheck<TResolve<T>>, value: unknown): boolean;
+    /**
+     * 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<T extends TIdiomaticSchema | TCatchall>(schema: T | TypeCheck<TResolve<T>>, value: unknown): ParseResult<TResolve<T>>;
+    /**
+     * Convert a schema to an OpenAPI schema object.
+     * @param {TIdiomaticSchema | TCatchall} schema - The schema to convert.
+     * @returns {SchemaObject} The OpenAPI schema object.
+     */
+    openapi<T extends TIdiomaticSchema | TCatchall>(schema: T): SchemaObject;
+}
+
 /**
  * Represents a catch-all schema type.
  */
@@ -29,7 +142,7 @@ type TObject<T> = T extends TObjectShape ? TObject$1<T> : TNever;
  *
  * @template T - The schema type to translate.
  */
-type TSchemaTranslate<T> = T extends TCatchall ? StaticDecode<T> : TNever;
+type TSchemaTranslate<T> = T extends TSchema ? StaticDecode<T> : TNever;
 /**
  * Represents an unboxed object schema where each key can have an idiomatic schema.
  */
@@ -39,7 +152,7 @@ type UnboxedTObjectSchema = {
 /**
  * Represents an idiomatic schema which can be an unboxed object schema or a literal schema.
  */
-type TIdiomaticSchema = UnboxedTObjectSchema | LiteralSchema;
+type TIdiomaticSchema = IdiomaticSchema<TypeboxSchemaValidator>;
 /**
  * Represents a container for a union of idiomatic schemas.
  */
@@ -49,16 +162,19 @@ type TUnionContainer = [...TIdiomaticSchema[]];
  *
  * @template T - The union container to resolve.
  */
-type UnionTResolve<T extends TUnionContainer> = T extends (infer UnionTypes)[] ? [TResolve<UnionTypes>] : TNever;
+type UnionTResolve<T extends TUnionContainer, Acc extends TIdiomaticSchema[] = []> = T extends [
+    infer Head extends TIdiomaticSchema,
+    ...infer Tail extends TUnionContainer
+] ? UnionTResolve<Tail, [...Acc, TResolve<Head>]> : T extends [] ? Acc : TNever[];
 /**
  * Resolves a schema type T to its resolved type. The depth is limited to 12 to prevent infinite recursion, due to StaticDecode limitations.
  *
  * @template T - The schema type to resolve.
  * @template Depth - The current depth of the resolution.
  */
-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 TypeCheck<infer Type> ? TResolve<Type, Increment<Depth>> : T extends UnboxedTObjectSchema ? TObject<{
+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 UnboxedTObjectSchema ? TObject<{
     [K in keyof T]: TResolve<T[K], Increment<Depth>>;
-}> : TNever;
+}> extends infer R ? R : TNever : T extends TypeCheck<infer Type> ? TResolve<Type, Increment<Depth>> : TNever;
 
 /**
  * This module provides a Zod-based schema definition.
@@ -227,14 +343,14 @@ type UnionZodResolve<T extends ZodUnionContainer> = T extends [
     }
 ] : [ZodNever, ZodNever];
 /**
- * Resolves a Zod schema type T to its resolved type. The depth is limited to 31 to prevent infinite recursion.
+ * Resolves a Zod schema type T to its resolved type. The depth is limited to 29 to prevent infinite recursion.
  *
  * @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 30 ? ZodUnknown : T extends LiteralSchema ? ZodLiteral<T> : T extends ZodType ? T : T extends UnboxedZodObjectSchema ? ZodObject<{
+type ZodResolve<T, Depth extends number = 0> = Depth extends 29 ? ZodUnknown : T extends LiteralSchema ? ZodLiteral<T> : T extends ZodType ? T : T extends UnboxedZodObjectSchema ? ZodObject<{
     [K in keyof T]: ZodResolve<T[K], Increment<Depth>>;
-}> : ZodNever;
+}> extends infer R ? R : ZodNever : ZodNever;
 
 /**
  * Represents an error with a path and message.
@@ -493,4 +609,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 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 };
+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, TypeboxSchemaValidator 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 TObject as m, type TSchemaTranslate as n, type UnboxedTObjectSchema as o, type ZodIdiomaticSchema as p, type ZodResolve as q, type ZodUnionContainer as r, type UnionZodResolve as s, type ZodCatchall as t, type ZodOuterArray as u, type ZodObjectShape as v, type ZodObject as w, type ZodSchemaTranslate as x, type UnboxedZodObjectSchema as y };

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

@@ -1,126 +1,11 @@
 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, j as TCatchall, a as ParseResult } from '../../schema.types-BA3PeCI5.mjs';
-export { l as TObjectShape, k as TOuterArray, m as TSchemaTranslate, n as UnboxedTObjectSchema } from '../../schema.types-BA3PeCI5.mjs';
+import { T as TypeboxSchemaValidator, f as TIdiomaticSchema, g as TResolve, h as TUnionContainer, i as UnionTResolve, L as LiteralSchema, j as TCatchall, a as ParseResult } from '../../schema.types-LkSEBFTv.mjs';
+export { m as TObject, l as TObjectShape, k as TOuterArray, n as TSchemaTranslate, o as UnboxedTObjectSchema } from '../../schema.types-LkSEBFTv.mjs';
 import * as _sinclair_typebox from '@sinclair/typebox';
-import { TProperties, TOptional, TArray, TUnion, TLiteral, TSchema } from '@sinclair/typebox';
 import '@forklaunch/common';
 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 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: TSchema;
-    _ValidSchemaObject: TObject<TProperties> | TArray<TObject<TProperties>>;
-    string: _sinclair_typebox.TString;
-    uuid: _sinclair_typebox.TString;
-    uri: _sinclair_typebox.TString;
-    email: _sinclair_typebox.TString;
-    number: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull, _sinclair_typebox.TDate, _sinclair_typebox.TBigInt]>, number>;
-    bigint: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TBigInt, _sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TDate]>, bigint>;
-    boolean: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TBoolean, _sinclair_typebox.TString]>, boolean>;
-    date: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TDate, _sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull]>, Date>;
-    symbol: _sinclair_typebox.TSymbol;
-    nullish: TUnion<[_sinclair_typebox.TVoid, _sinclair_typebox.TNull, _sinclair_typebox.TUndefined]>;
-    any: _sinclair_typebox.TAny;
-    unknown: _sinclair_typebox.TUnknown;
-    never: _sinclair_typebox.TNever;
-    /**
-     * 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.
-     */
-    private errorType;
-    /**
-     * Compiles schema if this exists, for optimal performance.
-     *
-     * @param {TObject<TProperties>} schema - The schema to compile.
-     * @returns {TypeCheck<T>} - The compiled schema.
-     */
-    compile<T extends TObject<TProperties>>(schema: T): TypeCheck<T>;
-    /**
-     * Convert a schema to a TypeBox schema.
-     * @param {TIdiomaticSchema} schema - The schema to convert.
-     * @returns {TResolve<T>} The resolved schema.
-     */
-    schemify<T extends TIdiomaticSchema>(schema: T): TResolve<T>;
-    /**
-     * Make a schema optional.
-     * @param {TIdiomaticSchema} schema - The schema to make optional.
-     * @returns {TOptional<TResolve<T>>} The optional schema.
-     */
-    optional<T extends TIdiomaticSchema>(schema: T): TOptional<TResolve<T>>;
-    /**
-     * Create an array schema.
-     * @param {TIdiomaticSchema} schema - The schema to use for array items.
-     * @returns {TArray<TResolve<T>>} The array schema.
-     */
-    array<T extends TIdiomaticSchema>(schema: T): TArray<TResolve<T>>;
-    /**
-     * Create a union schema.
-     * @param {TUnionContainer} schemas - The schemas to union.
-     * @returns {TUnion<UnionTResolve<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<T extends TUnionContainer>(schemas: [...T]): TUnion<UnionTResolve<T>>;
-    /**
-     * Create a literal schema.
-     * @param {LiteralSchema} value - The literal value.
-     * @returns {TLiteral<T>} The literal schema.
-     */
-    literal<T extends LiteralSchema>(value: T): TLiteral<T>;
-    /**
-     * Create an enum schema.
-     * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
-     * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
-     */
-    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.
-     * @returns {boolean} True if the value is a TypeBox object schema.
-     */
-    isSchema(value: unknown): value is TSchema;
-    /**
-     * 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<T extends TIdiomaticSchema | TSchema>(schema: T | TypeCheck<TResolve<T>>, value: unknown): boolean;
-    /**
-     * 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<T extends TIdiomaticSchema | TSchema>(schema: T | TypeCheck<TResolve<T>>, value: unknown): ParseResult<TResolve<T>>;
-    /**
-     * Convert a schema to an OpenAPI schema object.
-     * @param {TIdiomaticSchema | TSchema} schema - The schema to convert.
-     * @returns {SchemaObject} The OpenAPI schema object.
-     */
-    openapi<T extends TIdiomaticSchema | TSchema>(schema: T): SchemaObject;
-}
-
 /**
  * Factory function for creating a TypeboxSchemaValidator instance.
  * @returns {TypeboxSchemaValidator} The TypeboxSchemaValidator instance.
@@ -209,14 +94,14 @@ declare const isSchema: (value: unknown) => value is _sinclair_typebox.TSchema;
 /**
  * Validates a value against a valid schema.
  */
-declare const validate: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(schema: T | _sinclair_typebox_compiler.TypeCheck<TResolve<T>>, value: unknown) => boolean;
+declare const validate: <T extends TIdiomaticSchema | TCatchall>(schema: T | _sinclair_typebox_compiler.TypeCheck<TResolve<T>>, value: unknown) => boolean;
 /**
  * Parses a value against a valid schema.
  */
-declare const parse: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(schema: T | _sinclair_typebox_compiler.TypeCheck<TResolve<T>>, value: unknown) => ParseResult<TResolve<T>>;
+declare const parse: <T extends TIdiomaticSchema | TCatchall>(schema: T | _sinclair_typebox_compiler.TypeCheck<TResolve<T>>, value: unknown) => ParseResult<TResolve<T>>;
 /**
  * Generates an OpenAPI schema object from a valid schema.
  */
-declare const openapi: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(schema: T) => openapi3_ts_oas31.SchemaObject;
+declare const openapi: <T extends TIdiomaticSchema | TCatchall>(schema: T) => openapi3_ts_oas31.SchemaObject;
 
-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 };
+export { SchemaValidator, TCatchall, TIdiomaticSchema, 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

@@ -1,126 +1,11 @@
 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, j as TCatchall, a as ParseResult } from '../../schema.types-BA3PeCI5.js';
-export { l as TObjectShape, k as TOuterArray, m as TSchemaTranslate, n as UnboxedTObjectSchema } from '../../schema.types-BA3PeCI5.js';
+import { T as TypeboxSchemaValidator, f as TIdiomaticSchema, g as TResolve, h as TUnionContainer, i as UnionTResolve, L as LiteralSchema, j as TCatchall, a as ParseResult } from '../../schema.types-LkSEBFTv.js';
+export { m as TObject, l as TObjectShape, k as TOuterArray, n as TSchemaTranslate, o as UnboxedTObjectSchema } from '../../schema.types-LkSEBFTv.js';
 import * as _sinclair_typebox from '@sinclair/typebox';
-import { TProperties, TOptional, TArray, TUnion, TLiteral, TSchema } from '@sinclair/typebox';
 import '@forklaunch/common';
 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 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: TSchema;
-    _ValidSchemaObject: TObject<TProperties> | TArray<TObject<TProperties>>;
-    string: _sinclair_typebox.TString;
-    uuid: _sinclair_typebox.TString;
-    uri: _sinclair_typebox.TString;
-    email: _sinclair_typebox.TString;
-    number: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull, _sinclair_typebox.TDate, _sinclair_typebox.TBigInt]>, number>;
-    bigint: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TBigInt, _sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TDate]>, bigint>;
-    boolean: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TBoolean, _sinclair_typebox.TString]>, boolean>;
-    date: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TDate, _sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull]>, Date>;
-    symbol: _sinclair_typebox.TSymbol;
-    nullish: TUnion<[_sinclair_typebox.TVoid, _sinclair_typebox.TNull, _sinclair_typebox.TUndefined]>;
-    any: _sinclair_typebox.TAny;
-    unknown: _sinclair_typebox.TUnknown;
-    never: _sinclair_typebox.TNever;
-    /**
-     * 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.
-     */
-    private errorType;
-    /**
-     * Compiles schema if this exists, for optimal performance.
-     *
-     * @param {TObject<TProperties>} schema - The schema to compile.
-     * @returns {TypeCheck<T>} - The compiled schema.
-     */
-    compile<T extends TObject<TProperties>>(schema: T): TypeCheck<T>;
-    /**
-     * Convert a schema to a TypeBox schema.
-     * @param {TIdiomaticSchema} schema - The schema to convert.
-     * @returns {TResolve<T>} The resolved schema.
-     */
-    schemify<T extends TIdiomaticSchema>(schema: T): TResolve<T>;
-    /**
-     * Make a schema optional.
-     * @param {TIdiomaticSchema} schema - The schema to make optional.
-     * @returns {TOptional<TResolve<T>>} The optional schema.
-     */
-    optional<T extends TIdiomaticSchema>(schema: T): TOptional<TResolve<T>>;
-    /**
-     * Create an array schema.
-     * @param {TIdiomaticSchema} schema - The schema to use for array items.
-     * @returns {TArray<TResolve<T>>} The array schema.
-     */
-    array<T extends TIdiomaticSchema>(schema: T): TArray<TResolve<T>>;
-    /**
-     * Create a union schema.
-     * @param {TUnionContainer} schemas - The schemas to union.
-     * @returns {TUnion<UnionTResolve<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<T extends TUnionContainer>(schemas: [...T]): TUnion<UnionTResolve<T>>;
-    /**
-     * Create a literal schema.
-     * @param {LiteralSchema} value - The literal value.
-     * @returns {TLiteral<T>} The literal schema.
-     */
-    literal<T extends LiteralSchema>(value: T): TLiteral<T>;
-    /**
-     * Create an enum schema.
-     * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
-     * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
-     */
-    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.
-     * @returns {boolean} True if the value is a TypeBox object schema.
-     */
-    isSchema(value: unknown): value is TSchema;
-    /**
-     * 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<T extends TIdiomaticSchema | TSchema>(schema: T | TypeCheck<TResolve<T>>, value: unknown): boolean;
-    /**
-     * 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<T extends TIdiomaticSchema | TSchema>(schema: T | TypeCheck<TResolve<T>>, value: unknown): ParseResult<TResolve<T>>;
-    /**
-     * Convert a schema to an OpenAPI schema object.
-     * @param {TIdiomaticSchema | TSchema} schema - The schema to convert.
-     * @returns {SchemaObject} The OpenAPI schema object.
-     */
-    openapi<T extends TIdiomaticSchema | TSchema>(schema: T): SchemaObject;
-}
-
 /**
  * Factory function for creating a TypeboxSchemaValidator instance.
  * @returns {TypeboxSchemaValidator} The TypeboxSchemaValidator instance.
@@ -209,14 +94,14 @@ declare const isSchema: (value: unknown) => value is _sinclair_typebox.TSchema;
 /**
  * Validates a value against a valid schema.
  */
-declare const validate: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(schema: T | _sinclair_typebox_compiler.TypeCheck<TResolve<T>>, value: unknown) => boolean;
+declare const validate: <T extends TIdiomaticSchema | TCatchall>(schema: T | _sinclair_typebox_compiler.TypeCheck<TResolve<T>>, value: unknown) => boolean;
 /**
  * Parses a value against a valid schema.
  */
-declare const parse: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(schema: T | _sinclair_typebox_compiler.TypeCheck<TResolve<T>>, value: unknown) => ParseResult<TResolve<T>>;
+declare const parse: <T extends TIdiomaticSchema | TCatchall>(schema: T | _sinclair_typebox_compiler.TypeCheck<TResolve<T>>, value: unknown) => ParseResult<TResolve<T>>;
 /**
  * Generates an OpenAPI schema object from a valid schema.
  */
-declare const openapi: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(schema: T) => openapi3_ts_oas31.SchemaObject;
+declare const openapi: <T extends TIdiomaticSchema | TCatchall>(schema: T) => openapi3_ts_oas31.SchemaObject;
 
-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 };
+export { SchemaValidator, TCatchall, TIdiomaticSchema, 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

@@ -68,7 +68,6 @@ var TypeboxSchemaValidator = class {
   _SchemaCatchall;
   _ValidSchemaObject;
   string = import_typebox.Type.String();
-  // uuid = Type.String({ format: 'uuid' });
   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"
@@ -191,7 +190,7 @@ var TypeboxSchemaValidator = class {
    * @returns The type of the schema for error messages.
    */
   errorType(schema) {
-    if (Object.hasOwn(schema, "errorType")) {
+    if (import_typebox.KindGuard.IsSchema(schema) && Object.hasOwn(schema, "errorType")) {
       return schema.errorType;
     } else if (import_typebox.KindGuard.IsLiteral(schema)) {
       return schema.const;
@@ -374,7 +373,7 @@ var TypeboxSchemaValidator = class {
   }
   /**
    * Convert a schema to an OpenAPI schema object.
-   * @param {TIdiomaticSchema | TSchema} schema - The schema to convert.
+   * @param {TIdiomaticSchema | TCatchall} schema - The schema to convert.
    * @returns {SchemaObject} The OpenAPI schema object.
    */
   openapi(schema) {

package/lib/src/typebox/index.mjs

@@ -27,7 +27,6 @@ var TypeboxSchemaValidator = class {
   _SchemaCatchall;
   _ValidSchemaObject;
   string = Type.String();
-  // uuid = Type.String({ format: 'uuid' });
   uuid = Type.String({
     pattern: "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$",
     errorType: "uuid"
@@ -150,7 +149,7 @@ var TypeboxSchemaValidator = class {
    * @returns The type of the schema for error messages.
    */
   errorType(schema) {
-    if (Object.hasOwn(schema, "errorType")) {
+    if (KindGuard.IsSchema(schema) && Object.hasOwn(schema, "errorType")) {
       return schema.errorType;
     } else if (KindGuard.IsLiteral(schema)) {
       return schema.const;
@@ -333,7 +332,7 @@ var TypeboxSchemaValidator = class {
   }
   /**
    * Convert a schema to an OpenAPI schema object.
-   * @param {TIdiomaticSchema | TSchema} schema - The schema to convert.
+   * @param {TIdiomaticSchema | TCatchall} schema - The schema to convert.
    * @returns {SchemaObject} The OpenAPI schema object.
    */
   openapi(schema) {

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

@@ -1,6 +1,6 @@
 import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
-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-BA3PeCI5.mjs';
-export { x as UnboxedZodObjectSchema, v as ZodObject, u as ZodObjectShape, t as ZodOuterArray, w as ZodSchemaTranslate } from '../../schema.types-BA3PeCI5.mjs';
+import { Z as ZodSchemaValidator, p as ZodIdiomaticSchema, q as ZodResolve, r as ZodUnionContainer, s as UnionZodResolve, L as LiteralSchema, t as ZodCatchall, a as ParseResult } from '../../schema.types-LkSEBFTv.mjs';
+export { y as UnboxedZodObjectSchema, w as ZodObject, v as ZodObjectShape, u as ZodOuterArray, x as ZodSchemaTranslate } from '../../schema.types-LkSEBFTv.mjs';
 import * as zod from 'zod';
 import '@forklaunch/common';
 import '@sinclair/typebox';

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

@@ -1,6 +1,6 @@
 import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
-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-BA3PeCI5.js';
-export { x as UnboxedZodObjectSchema, v as ZodObject, u as ZodObjectShape, t as ZodOuterArray, w as ZodSchemaTranslate } from '../../schema.types-BA3PeCI5.js';
+import { Z as ZodSchemaValidator, p as ZodIdiomaticSchema, q as ZodResolve, r as ZodUnionContainer, s as UnionZodResolve, L as LiteralSchema, t as ZodCatchall, a as ParseResult } from '../../schema.types-LkSEBFTv.js';
+export { y as UnboxedZodObjectSchema, w as ZodObject, v as ZodObjectShape, u as ZodOuterArray, x as ZodSchemaTranslate } from '../../schema.types-LkSEBFTv.js';
 import * as zod from 'zod';
 import '@forklaunch/common';
 import '@sinclair/typebox';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forklaunch/validator",
-  "version": "0.4.11",
+  "version": "0.4.12",
   "description": "Schema validator for ForkLaunch components.",
   "homepage": "https://github.com/forklaunch/forklaunch-js#readme",
   "bugs": {