@forklaunch/validator 0.4.12 → 0.5.0

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

@@ -1,19 +1,19 @@
 import { Prettify } from '@forklaunch/common';
 import { SchemaObject } from 'openapi3-ts/oas31';
 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 { 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 TUnionContainer>(schemas: [...T]) => TUnion<UnionTResolve<T>>, <T extends LiteralSchema>(value: T) => TLiteral<T>, <T extends Record<string, LiteralSchema>>(schemaEnum: T) => TUnion<[
+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]
-]>, (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> {
+]>, <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>>;
@@ -27,6 +27,9 @@ declare class TypeboxSchemaValidator implements SchemaValidator<(<T extends TObj
     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;
@@ -64,13 +67,13 @@ declare class TypeboxSchemaValidator implements SchemaValidator<(<T extends TObj
     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.
+     * @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 TUnionContainer>(schemas: [...T]): TUnion<UnionTResolve<T>>;
+    union<T extends TUnionTupleContainer>(schemas: [...T]): TUnion<UnionTupleTResolve<T>>;
     /**
      * Create a literal schema.
      * @param {LiteralSchema} value - The literal value.
@@ -80,13 +83,33 @@ declare class TypeboxSchemaValidator implements SchemaValidator<(<T extends TObj
     /**
      * Create an enum schema.
      * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
-     * @returns {TUnion<UnionTResolve<T[]>>} 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.
@@ -156,16 +179,16 @@ 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, Acc extends TIdiomaticSchema[] = []> = T extends [
+type UnionTupleTResolve<T extends TUnionTupleContainer, Acc extends TIdiomaticSchema[] = []> = T extends [
     infer Head extends TIdiomaticSchema,
-    ...infer Tail extends TUnionContainer
-] ? UnionTResolve<Tail, [...Acc, TResolve<Head>]> : T extends [] ? Acc : TNever[];
+    ...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.
  *
@@ -187,11 +210,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 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>>;
@@ -204,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;
@@ -244,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.
@@ -255,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.
@@ -318,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.
  */
@@ -351,6 +415,12 @@ type UnionZodResolve<T extends ZodUnionContainer> = T extends [
 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>>;
 }> 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.
@@ -382,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.
      */
@@ -496,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.
      *
@@ -530,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.
      */
@@ -579,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.
  *
@@ -609,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, 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 };
+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 };

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

@@ -1,19 +1,19 @@
 import { Prettify } from '@forklaunch/common';
 import { SchemaObject } from 'openapi3-ts/oas31';
 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 { 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 TUnionContainer>(schemas: [...T]) => TUnion<UnionTResolve<T>>, <T extends LiteralSchema>(value: T) => TLiteral<T>, <T extends Record<string, LiteralSchema>>(schemaEnum: T) => TUnion<[
+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]
-]>, (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> {
+]>, <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>>;
@@ -27,6 +27,9 @@ declare class TypeboxSchemaValidator implements SchemaValidator<(<T extends TObj
     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;
@@ -64,13 +67,13 @@ declare class TypeboxSchemaValidator implements SchemaValidator<(<T extends TObj
     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.
+     * @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 TUnionContainer>(schemas: [...T]): TUnion<UnionTResolve<T>>;
+    union<T extends TUnionTupleContainer>(schemas: [...T]): TUnion<UnionTupleTResolve<T>>;
     /**
      * Create a literal schema.
      * @param {LiteralSchema} value - The literal value.
@@ -80,13 +83,33 @@ declare class TypeboxSchemaValidator implements SchemaValidator<(<T extends TObj
     /**
      * Create an enum schema.
      * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
-     * @returns {TUnion<UnionTResolve<T[]>>} 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.
@@ -156,16 +179,16 @@ 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, Acc extends TIdiomaticSchema[] = []> = T extends [
+type UnionTupleTResolve<T extends TUnionTupleContainer, Acc extends TIdiomaticSchema[] = []> = T extends [
     infer Head extends TIdiomaticSchema,
-    ...infer Tail extends TUnionContainer
-] ? UnionTResolve<Tail, [...Acc, TResolve<Head>]> : T extends [] ? Acc : TNever[];
+    ...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.
  *
@@ -187,11 +210,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 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>>;
@@ -204,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;
@@ -244,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.
@@ -255,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.
@@ -318,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.
  */
@@ -351,6 +415,12 @@ type UnionZodResolve<T extends ZodUnionContainer> = T extends [
 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>>;
 }> 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.
@@ -382,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.
      */
@@ -496,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.
      *
@@ -530,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.
      */
@@ -579,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.
  *
@@ -609,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, 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 };
+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 };

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

@@ -1,7 +1,7 @@
 import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
 import * as _sinclair_typebox_compiler from '@sinclair/typebox/compiler';
-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 { T as TypeboxSchemaValidator, f as TIdiomaticSchema, g as TResolve, h as TUnionTupleContainer, i as UnionTupleTResolve, L as LiteralSchema, j as TCatchall, a as ParseResult } from '../../schema.types-BL6n8u4w.mjs';
+export { m as TObject, l as TObjectShape, k as TOuterArray, n as TSchemaTranslate, o as UnboxedTObjectSchema } from '../../schema.types-BL6n8u4w.mjs';
 import * as _sinclair_typebox from '@sinclair/typebox';
 import '@forklaunch/common';
 import 'zod';
@@ -51,6 +51,18 @@ declare const symbol: _sinclair_typebox.TSymbol;
  * TypeBox schema definition for undefined, null, void types.
  */
 declare const nullish: _sinclair_typebox.TUnion<[_sinclair_typebox.TVoid, _sinclair_typebox.TNull, _sinclair_typebox.TUndefined]>;
+/**
+ * TypeBox schema definition for void type.
+ */
+declare const void_: _sinclair_typebox.TVoid;
+/**
+ * TypeBox schema definition for null type.
+ */
+declare const null_: _sinclair_typebox.TNull;
+/**
+ * TypeBox schema definition for undefined type.
+ */
+declare const undefined_: _sinclair_typebox.TUndefined;
 /**
  * TypeBox schema definition for any type.
  */
@@ -78,7 +90,7 @@ declare const array: <T extends TIdiomaticSchema>(schema: T) => _sinclair_typebo
 /**
  * Defines a union for a valid schema.
  */
-declare const union: <T extends TUnionContainer>(schemas: [...T]) => _sinclair_typebox.TUnion<UnionTResolve<T>>;
+declare const union: <T extends TUnionTupleContainer>(schemas: [...T]) => _sinclair_typebox.TUnion<UnionTupleTResolve<T>>;
 /**
  * Defines a literal for a valid schema.
  */
@@ -87,6 +99,18 @@ declare const literal: <T extends LiteralSchema>(value: T) => _sinclair_typebox.
  * Defines an enum for a valid schema.
  */
 declare const enum_: <T extends Record<string, LiteralSchema>>(schemaEnum: T) => _sinclair_typebox.TUnion<[{ [K in keyof T]: _sinclair_typebox.TLiteral<T[K]>; }[keyof T]]>;
+/**
+ * Defines a function for a valid schema.
+ */
+declare const function_: <Args extends TUnionTupleContainer, ReturnType extends TIdiomaticSchema>(args: [...Args], returnType: ReturnType) => _sinclair_typebox.TFunction<UnionTupleTResolve<Args>, TResolve<ReturnType>>;
+/**
+ * Defines a record for a valid schema.
+ */
+declare const record: <Key extends TIdiomaticSchema, Value extends TIdiomaticSchema>(key: Key, value: Value) => _sinclair_typebox.TRecord<TResolve<Key>, TResolve<Value>>;
+/**
+ * Defines a promise for a valid schema.
+ */
+declare const promise: <T extends TIdiomaticSchema>(schema: T) => _sinclair_typebox.TPromise<TResolve<T>>;
 /**
  * Checks if a value is a TypeBox schema.
  */
@@ -104,4 +128,4 @@ declare const parse: <T extends TIdiomaticSchema | TCatchall>(schema: T | _sincl
  */
 declare const openapi: <T extends TIdiomaticSchema | TCatchall>(schema: T) => openapi3_ts_oas31.SchemaObject;
 
-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 };
+export { SchemaValidator, TCatchall, TIdiomaticSchema, TResolve, TUnionTupleContainer, TypeboxSchemaValidator, UnionTupleTResolve, any, array, bigint, boolean, date, email, enum_, function_, isSchema, literal, never, null_, nullish, number, openapi, optional, parse, promise, record, schemify, string, symbol, undefined_, union, unknown, uri, uuid, validate, void_ };