@forklaunch/validator 0.4.11 → 0.5.0

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

@@ -1,8 +1,144 @@
 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, TFunction, TRecord, TPromise, 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';
+import { ZodObject as ZodObject$1, ZodRawShape, ZodOptional, ZodArray, ZodUnion, ZodLiteral, ZodFunction, ZodTuple, ZodRecord, ZodPromise, 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 TUnionTupleContainer>(schemas: [...T]) => TUnion<UnionTupleTResolve<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]
+]>, <Args extends TUnionTupleContainer, ReturnType extends TIdiomaticSchema>(args: [...Args], returnType: ReturnType) => TFunction<UnionTupleTResolve<Args>, TResolve<ReturnType>>, <Key extends TIdiomaticSchema, Value extends TIdiomaticSchema>(key: Key, value: Value) => TRecord<TResolve<Key>, TResolve<Value>>, <T extends TIdiomaticSchema>(schema: T) => TPromise<TResolve<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]>;
+    void: _sinclair_typebox.TVoid;
+    null: _sinclair_typebox.TNull;
+    undefined: _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 {TUnionTupleContainer} schemas - The schemas to union.
+     * @returns {TUnion<UnionTupleTResolve<T>>} The union schema.
+     *
+     * WARNING: If "nullish" or TUndefined is included in the union, the key will still be expected.
+     * This is a limitation of TypeBox. Consider using "optional" instead.
+     */
+    union<T extends TUnionTupleContainer>(schemas: [...T]): TUnion<UnionTupleTResolve<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<UnionTupleTResolve<T[]>>} The enum schema.
+     */
+    enum_<T extends Record<string, LiteralSchema>>(schemaEnum: T): TUnion<[
+        {
+            [K in keyof T]: TLiteral<T[K]>;
+        }[keyof T]
+    ]>;
+    /**
+     * Create a function schema.
+     * @param {TSchema[]} args - The arguments of the function.
+     * @param {TAny} returnType - The return type of the function.
+     * @returns {TFunction<Args, ReturnType>} The function schema.
+     */
+    function_<Args extends TUnionTupleContainer, ReturnType extends TIdiomaticSchema>(args: [...Args], returnType: ReturnType): TFunction<UnionTupleTResolve<Args>, TResolve<ReturnType>>;
+    /**
+     * Create a record schema.
+     * @param {TIdiomaticSchema} key - The key schema.
+     * @param {TIdiomaticSchema} value - The value schema.
+     * @returns {TRecord<TResolve<Key>, TResolve<Value>>} The record schema.
+     */
+    record<Key extends TIdiomaticSchema, Value extends TIdiomaticSchema>(key: Key, value: Value): TRecord<TResolve<Key>, TResolve<Value>>;
+    /**
+     * Create a promise schema.
+     * @param {TIdiomaticSchema} schema - The schema to use for the promise.
+     * @returns {TPromise<TResolve<T>>} The promise schema.
+     */
+    promise<T extends TIdiomaticSchema>(schema: T): TPromise<TResolve<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 +165,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,26 +175,29 @@ 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.
  */
-type TUnionContainer = [...TIdiomaticSchema[]];
+type TUnionTupleContainer = [...TIdiomaticSchema[]];
 /**
  * Resolves a union container to a tuple of resolved idiomatic schemas.
  *
  * @template T - The union container to resolve.
  */
-type UnionTResolve<T extends TUnionContainer> = T extends (infer UnionTypes)[] ? [TResolve<UnionTypes>] : TNever;
+type UnionTupleTResolve<T extends TUnionTupleContainer, Acc extends TIdiomaticSchema[] = []> = T extends [
+    infer Head extends TIdiomaticSchema,
+    ...infer Tail extends TUnionTupleContainer
+] ? UnionTupleTResolve<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.
@@ -71,11 +210,11 @@ type TResolve<T, Depth extends number = 0> = Depth extends 10 ? 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 Record<string, LiteralSchema>>(schemaEnum: T) => ZodUnion<[
+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<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> {
+]>, <Args extends ZodTupleContainer, ReturnType extends ZodIdiomaticSchema>(args: Args, returnType: ReturnType) => ZodFunction<ZodTuple<TupleZodResolve<Args>, null>, ZodResolve<ReturnType>>, <Key extends ZodIdiomaticSchema, Value extends ZodIdiomaticSchema>(key: Key, value: Value) => ZodRecord<ZodRecordKey<Key>, ZodResolve<Value>>, <T extends ZodIdiomaticSchema>(schema: T) => ZodPromise<ZodResolve<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>>;
@@ -88,7 +227,10 @@ declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObjec
     boolean: z.ZodEffects<z.ZodBoolean, boolean, unknown>;
     date: z.ZodPipeline<z.ZodEffects<z.ZodAny, any, any>, z.ZodDate>;
     symbol: z.ZodSymbol;
-    nullish: ZodUnion<[z.ZodVoid, z.ZodNull, z.ZodUndefined]>;
+    nullish: z.ZodUnion<[z.ZodVoid, z.ZodNull, z.ZodUndefined]>;
+    void: z.ZodVoid;
+    null: z.ZodNull;
+    undefined: z.ZodUndefined;
     any: z.ZodAny;
     unknown: z.ZodUnknown;
     never: z.ZodNever;
@@ -128,7 +270,7 @@ declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObjec
      * @param {LiteralSchema} value - The literal value.
      * @returns {ZodLiteral<ZodResolve<T>>} The literal schema.
      */
-    literal<T extends LiteralSchema>(value: T): ZodLiteral<ZodResolve<T>>;
+    literal<T extends LiteralSchema>(value: T): ZodLiteral<T>;
     /**
      * Create an enum schema.
      * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
@@ -139,6 +281,26 @@ declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObjec
             [K in keyof T]: ZodLiteral<T[K]>;
         }[keyof T]
     ]>;
+    /**
+     * Create a function schema.
+     * @param {ZodTuple} args - The arguments of the function.
+     * @param {ZodAny} returnType - The return type of the function.
+     * @returns {ZodFunction<Args, ReturnType>} The function schema.
+     */
+    function_<Args extends ZodTupleContainer, ReturnType extends ZodIdiomaticSchema>(args: Args, returnType: ReturnType): ZodFunction<ZodTuple<TupleZodResolve<Args>, null>, ZodResolve<ReturnType>>;
+    /**
+     * Create a record schema.
+     * @param {ZodIdiomaticSchema} key - The key schema.
+     * @param {ZodIdiomaticSchema} value - The value schema.
+     * @returns {ZodRecord<ZodResolve<Key>, ZodResolve<Value>>} The record schema.
+     */
+    record<Key extends ZodIdiomaticSchema, Value extends ZodIdiomaticSchema>(key: Key, value: Value): ZodRecord<ZodRecordKey<Key>, ZodResolve<Value>>;
+    /**
+     * Create a promise schema.
+     * @param {ZodIdiomaticSchema} schema - The schema to use for the promise.
+     * @returns {ZodPromise<ZodResolve<T>>} The promise schema.
+     */
+    promise<T extends ZodIdiomaticSchema>(schema: T): ZodPromise<ZodResolve<T>>;
     /**
      * Checks if a value is a Zod schema.
      * @param {unknown} value - The value to check.
@@ -202,6 +364,24 @@ type UnboxedZodObjectSchema = UnboxedObjectSchema<ZodSchemaValidator>;
  * Represents an idiomatic schema for Zod which can be an unboxed object schema or a literal schema.
  */
 type ZodIdiomaticSchema = IdiomaticSchema<ZodSchemaValidator>;
+/**
+ * Represents a container for a union of Zod idiomatic schemas.
+ */
+type ZodTupleContainer = readonly [] | readonly [ZodIdiomaticSchema, ...ZodIdiomaticSchema[]];
+/**
+ * Resolves a union container to a tuple of resolved Zod idiomatic schemas.
+ *
+ * @template T - The union container to resolve.
+ */
+type TupleZodResolve<T extends ZodTupleContainer> = T extends [
+    infer A extends ZodIdiomaticSchema,
+    ...infer B extends ZodIdiomaticSchema[]
+] ? [
+    ZodResolve<A>,
+    ...{
+        [K in keyof B]: ZodResolve<B[K]>;
+    }
+] : [];
 /**
  * Represents a container for a union of Zod idiomatic schemas.
  */
@@ -227,14 +407,20 @@ 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 the key type of a Zod record schema.
+ *
+ * @template T - The Zod idiomatic schema to get the key type from.
+ */
+type ZodRecordKey<T extends ZodIdiomaticSchema> = ZodResolve<T> extends infer R ? R extends boolean ? never : unknown extends R ? never : R : never;
 
 /**
  * Represents an error with a path and message.
@@ -266,7 +452,7 @@ type ParseResult<T> = {
  * @template ParseFunction - The function type for parsing a value against a schema.
  * @template OpenAPIFunction - The function type for converting a schema into an OpenAPI schema object.
  */
-interface SchemaValidator<CompilationFunction = <T>(schema: T) => unknown, SchematicFunction = <T>(schema: T) => unknown, OptionalFunction = <T>(schema: T) => unknown, ArrayFunction = <T>(schema: T) => unknown, UnionFunction = <T>(schemas: T[]) => unknown, LiteralFunction = <T extends LiteralSchema>(schema: T) => unknown, EnumFunction = <T extends LiteralSchema>(schemaEnum: Record<string, T>) => unknown, SchemaGuardFunction = <T>(value: unknown) => value is T, ValidationFunction = <T>(schema: T, value: unknown) => boolean, ParseFunction = <T>(schema: T, value: unknown) => ParseResult<SchemaResolve<T>>, OpenAPIFunction = <T>(schema: T) => SchemaObject> {
+interface SchemaValidator<CompilationFunction = <T>(schema: T) => unknown, SchematicFunction = <T>(schema: T) => unknown, OptionalFunction = <T>(schema: T) => unknown, ArrayFunction = <T>(schema: T) => unknown, UnionFunction = <T>(schemas: T[]) => unknown, LiteralFunction = <T extends LiteralSchema>(schema: T) => unknown, EnumFunction = <T extends LiteralSchema>(schemaEnum: Record<string, T>) => unknown, FunctionFunction = <Args, ReturnType>(args: Args, returnType: ReturnType) => unknown, RecordFunction = <Key, Value>(key: Key, value: Value) => unknown, PromiseFunction = <T>(schema: T) => unknown, SchemaGuardFunction = <T>(value: unknown) => value is T, ValidationFunction = <T>(schema: T, value: unknown) => boolean, ParseFunction = <T>(schema: T, value: unknown) => ParseResult<SchemaResolve<T>>, OpenAPIFunction = <T>(schema: T) => SchemaObject> {
     /**
      * The type of the schema validator.
      */
@@ -380,6 +566,29 @@ interface SchemaValidator<CompilationFunction = <T>(schema: T) => unknown, Schem
      * @returns {unknown} - The enum schema.
      */
     enum_: EnumFunction;
+    /**
+     * Creates a function schema from a tuple of arguments and a return type.
+     *
+     * @param {Args} args - The arguments of the function.
+     * @param {ReturnType} returnType - The return type of the function.
+     * @returns {unknown} - The function schema.
+     */
+    function_: FunctionFunction;
+    /**
+     * Creates a promise schema from a schema.
+     *
+     * @param {T} schema - The schema to use for the promise.
+     * @returns {unknown} - The promise schema.
+     */
+    promise: PromiseFunction;
+    /**
+     * Creates a record schema from a key and value schema.
+     *
+     * @param {Key} key - The key schema.
+     * @param {Value} value - The value schema.
+     * @returns {unknown} - The record schema.
+     */
+    record: RecordFunction;
     /**
      * Checks if a value is a schema.
      *
@@ -414,7 +623,7 @@ interface SchemaValidator<CompilationFunction = <T>(schema: T) => unknown, Schem
 /**
  * Type representing any schema validator.
  */
-type AnySchemaValidator = SchemaValidator<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> & {
+type AnySchemaValidator = SchemaValidator<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> & {
     /**
      * The type of the schema resolver.
      */
@@ -463,7 +672,7 @@ type SchemaPrettify<T, SV extends AnySchemaValidator> = Prettify<SchemaTranslate
  * @template T - The type of the schema.
  * @template SV - The type of the schema validator.
  */
-type Schema<T extends SV['_ValidSchemaObject'] | IdiomaticSchema<SV>, SV extends AnySchemaValidator> = SchemaPrettify<SchemaResolve<T>[SV['_Type']], SV>;
+type Schema<T extends SV['_ValidSchemaObject'] | IdiomaticSchema<SV>, SV extends AnySchemaValidator> = SchemaTranslate<SchemaResolve<T>[SV['_Type']]>[SV['_Type']] extends infer Schema ? Schema extends (...args: infer Args) => infer Return ? (...args: Args) => Return : SchemaPrettify<SchemaResolve<T>[SV['_Type']], SV> : never;
 /**
  * Represents a schema for an unboxed object where each key can have an idiomatic schema.
  *
@@ -493,4 +702,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 ZodSchemaTranslate as B, type UnboxedZodObjectSchema as C, 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 TUnionTupleContainer as h, type UnionTupleTResolve 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 ZodTupleContainer as t, type TupleZodResolve as u, type ZodRecordKey as v, type ZodCatchall as w, type ZodOuterArray as x, type ZodObjectShape as y, type ZodObject as z };