elysia 2.0.0-exp.2 → 2.0.0-exp.21

package/dist/type/exports.mjs

@@ -1,4 +1,4 @@
-import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { __exportAll, __reExport } from "../_virtual/_rolldown/runtime.mjs";
 import { ArrayType } from "./elysia/array.mjs";
 import { StringType } from "./elysia/string.mjs";
 import { Union } from "./elysia/union.mjs";
@@ -27,330 +27,42 @@ import { NumericEnum } from "./elysia/numeric-enum.mjs";
 import { Optional } from "./elysia/optional.mjs";
 import { Uint8ArrayType } from "./elysia/uint8-array.mjs";
 import { UnionEnum } from "./elysia/union-enum.mjs";
-import { AddImmutable, AddImmutableDeferred, AddOptional, AddOptionalDeferred, AddReadonly, AddReadonlyDeferred, Any, ArrayOptions, AsyncIterator, AsyncIteratorOptions, Awaited, AwaitedAction, AwaitedDeferred, AwaitedInstantiate, Base, BigInt, BigIntPattern, Broaden, Call, CallConstruct, Capitalize, CapitalizeAction, CapitalizeDeferred, CapitalizeInstantiate, Codec, CollapseToObject, Compare, Composite, Conditional, ConditionalAction, ConditionalDeferred, ConditionalInstantiate, Constructor, ConstructorOptions, ConstructorParameters, ConstructorParametersAction, ConstructorParametersDeferred, ConstructorParametersInstantiate, ConvertToIntegerKey, Cyclic, CyclicCandidates, CyclicCheck, CyclicDependencies, CyclicExtends, CyclicOptions, CyclicTarget, Decode, DecodeBuilder, Deferred, Dependent, DependentOptions, Distribute, Encode, EncodeBuilder, Enum, Evaluate, EvaluateAction, EvaluateDeferred, EvaluateDependent, EvaluateEnum, EvaluateInstantiate, EvaluateIntersect, EvaluateTemplateLiteral, EvaluateType, EvaluateUnion, EvaluateUnionFast, Exclude, ExcludeAction, ExcludeDeferred, ExcludeInstantiate, Extends, ExtendsResult, Extract, ExtractAction, ExtractDeferred, ExtractInstantiate, Flatten, Function, FunctionOptions, Generic, Identifier, Immutable, Index, IndexAction, IndexDeferred, IndexInstantiate, Infer, InstanceType, InstanceTypeAction, InstanceTypeDeferred, InstanceTypeInstantiate, Instantiate, InstantiateCyclic, IntegerKey, IntegerPattern, Interface, InterfaceAction, InterfaceDeferred, InterfaceInstantiate, IntersectOptions, InvalidLiteralValue, IsAny, IsArray, IsAsyncIterator, IsBase, IsBigInt, IsBoolean, IsCall, IsCodec, IsConstructor, IsCyclic, IsDeferred, IsDependent, IsEnum, IsFunction, IsGeneric, IsIdentifier, IsImmutable, IsInfer, IsInteger, IsInterfaceDeferred, IsIntersect, IsIterator, IsKind, IsLiteral, IsLiteralBigInt, IsLiteralBoolean, IsLiteralNumber, IsLiteralString, IsLiteralValue, IsNever, IsNull, IsNumber, IsObject, IsOptional, IsParameter, IsPromise, IsReadonly, IsRecord, IsRef, IsRefine, IsRefinement, IsRest, IsSchema, IsString, IsSymbol, IsTemplateLiteral, IsTemplateLiteralDeferred, IsTemplateLiteralFinite, IsTemplateLiteralPattern, IsThis, IsTuple, IsTypeScriptEnumLike, IsUndefined, IsUnion, IsUnknown, IsUnsafe, IsVoid, Iterator, IteratorOptions, KeyOf, KeyOfAction, KeyOfDeferred, KeyOfInstantiate, KeysToIndexer, Literal, LiteralTypeName, Lowercase, LowercaseAction, LowercaseDeferred, LowercaseInstantiate, Mapped, MappedAction, MappedDeferred, MappedInstantiate, Module, ModuleDeferred, ModuleInstantiate, Narrow, Never, NeverPattern, NonNullable, NonNullableAction, NonNullableDeferred, NonNullableInstantiate, Null, NumberKey, NumberPattern, ObjectOptions, Omit, OmitAction, OmitDeferred, OmitInstantiate, Options, Parameter, Parameters, ParametersAction, ParametersDeferred, ParametersInstantiate, ParsePatternIntoTypes, ParseTemplateIntoTypes, Partial, PartialAction, PartialDeferred, PartialInstantiate, Pick, PickAction, PickDeferred, PickInstantiate, Priority, Promise as Promise$1, PromiseOptions, PropertyKeys, PropertyValues, Readonly, ReadonlyObject, ReadonlyObjectAction, ReadonlyObjectDeferred, ReadonlyObjectInstantiate, ReadonlyType, Record, RecordAction, RecordDeferred, RecordFromPattern, RecordInstantiate, RecordKey, RecordOptions, RecordPattern, RecordPatternToType, RecordValue, Ref, RefInstantiate, Refine, RefineAdd, RemoveImmutable, RemoveImmutableDeferred, RemoveOptional, RemoveOptionalDeferred, RemoveReadonly, RemoveReadonlyDeferred, Required, RequiredAction, RequiredArray, RequiredDeferred, RequiredInstantiate, Rest, ResultDisjoint, ResultEqual, ResultLeftInside, ResultRightInside, ReturnType, ReturnTypeAction, ReturnTypeDeferred, ReturnTypeInstantiate, Script, StringKey, StringPattern, Symbol, TemplateLiteral, TemplateLiteralCreate, TemplateLiteralDecode, TemplateLiteralDecodeUnsafe, TemplateLiteralDeferred, TemplateLiteralEncode, TemplateLiteralFromString, TemplateLiteralFromTypes, This, Tuple, TupleOptions, TypeScriptEnumToEnumValues, Uncapitalize, UncapitalizeAction, UncapitalizeDeferred, UncapitalizeInstantiate, Undefined, UnionOptions, Unknown, Unsafe, Uppercase, UppercaseAction, UppercaseDeferred, UppercaseInstantiate, Void, With, WithAction, WithDeferred, WithInstantiate, _Array_, _Function_, _Object_, _Promise_ } from "typebox/type";
+
+export * from "typebox/type"
 
 //#region src/type/exports.ts
 var exports_exports = /* @__PURE__ */ __exportAll({
 	Accelerate: () => Accelerate,
-	AddImmutable: () => AddImmutable,
-	AddImmutableDeferred: () => AddImmutableDeferred,
-	AddOptional: () => AddOptional,
-	AddOptionalDeferred: () => AddOptionalDeferred,
-	AddReadonly: () => AddReadonly,
-	AddReadonlyDeferred: () => AddReadonlyDeferred,
-	Any: () => Any,
 	Array: () => ArrayType,
 	ArrayBuffer: () => ArrayBufferType,
-	ArrayOptions: () => ArrayOptions,
 	ArrayString: () => ArrayString,
-	AsyncIterator: () => AsyncIterator,
-	AsyncIteratorOptions: () => AsyncIteratorOptions,
-	Awaited: () => Awaited,
-	AwaitedAction: () => AwaitedAction,
-	AwaitedDeferred: () => AwaitedDeferred,
-	AwaitedInstantiate: () => AwaitedInstantiate,
-	Base: () => Base,
-	BigInt: () => BigInt,
-	BigIntPattern: () => BigIntPattern,
 	Boolean: () => BooleanType,
 	BooleanString: () => BooleanString,
-	Broaden: () => Broaden,
-	Call: () => Call,
-	CallConstruct: () => CallConstruct,
-	Capitalize: () => Capitalize,
-	CapitalizeAction: () => CapitalizeAction,
-	CapitalizeDeferred: () => CapitalizeDeferred,
-	CapitalizeInstantiate: () => CapitalizeInstantiate,
-	Codec: () => Codec,
-	CollapseToObject: () => CollapseToObject,
-	Compare: () => Compare,
-	Composite: () => Composite,
-	Conditional: () => Conditional,
-	ConditionalAction: () => ConditionalAction,
-	ConditionalDeferred: () => ConditionalDeferred,
-	ConditionalInstantiate: () => ConditionalInstantiate,
-	Constructor: () => Constructor,
-	ConstructorOptions: () => ConstructorOptions,
-	ConstructorParameters: () => ConstructorParameters,
-	ConstructorParametersAction: () => ConstructorParametersAction,
-	ConstructorParametersDeferred: () => ConstructorParametersDeferred,
-	ConstructorParametersInstantiate: () => ConstructorParametersInstantiate,
-	ConvertToIntegerKey: () => ConvertToIntegerKey,
 	Cookie: () => Cookie,
-	Cyclic: () => Cyclic,
-	CyclicCandidates: () => CyclicCandidates,
-	CyclicCheck: () => CyclicCheck,
-	CyclicDependencies: () => CyclicDependencies,
-	CyclicExtends: () => CyclicExtends,
-	CyclicOptions: () => CyclicOptions,
-	CyclicTarget: () => CyclicTarget,
 	Date: () => DateType,
-	Decode: () => Decode,
-	DecodeBuilder: () => DecodeBuilder,
-	Deferred: () => Deferred,
-	Dependent: () => Dependent,
-	DependentOptions: () => DependentOptions,
-	Distribute: () => Distribute,
-	Encode: () => Encode,
-	EncodeBuilder: () => EncodeBuilder,
-	Enum: () => Enum,
-	Evaluate: () => Evaluate,
-	EvaluateAction: () => EvaluateAction,
-	EvaluateDeferred: () => EvaluateDeferred,
-	EvaluateDependent: () => EvaluateDependent,
-	EvaluateEnum: () => EvaluateEnum,
-	EvaluateInstantiate: () => EvaluateInstantiate,
-	EvaluateIntersect: () => EvaluateIntersect,
-	EvaluateTemplateLiteral: () => EvaluateTemplateLiteral,
-	EvaluateType: () => EvaluateType,
-	EvaluateUnion: () => EvaluateUnion,
-	EvaluateUnionFast: () => EvaluateUnionFast,
-	Exclude: () => Exclude,
-	ExcludeAction: () => ExcludeAction,
-	ExcludeDeferred: () => ExcludeDeferred,
-	ExcludeInstantiate: () => ExcludeInstantiate,
-	Extends: () => Extends,
-	ExtendsResult: () => ExtendsResult,
-	Extract: () => Extract,
-	ExtractAction: () => ExtractAction,
-	ExtractDeferred: () => ExtractDeferred,
-	ExtractInstantiate: () => ExtractInstantiate,
 	File: () => File,
 	Files: () => Files,
-	Flatten: () => Flatten,
 	Form: () => Form,
-	Function: () => Function,
-	FunctionOptions: () => FunctionOptions,
-	Generic: () => Generic,
-	Identifier: () => Identifier,
-	Immutable: () => Immutable,
-	Index: () => Index,
-	IndexAction: () => IndexAction,
-	IndexDeferred: () => IndexDeferred,
-	IndexInstantiate: () => IndexInstantiate,
-	Infer: () => Infer,
-	InstanceType: () => InstanceType,
-	InstanceTypeAction: () => InstanceTypeAction,
-	InstanceTypeDeferred: () => InstanceTypeDeferred,
-	InstanceTypeInstantiate: () => InstanceTypeInstantiate,
-	Instantiate: () => Instantiate,
-	InstantiateCyclic: () => InstantiateCyclic,
 	Integer: () => Integer,
-	IntegerKey: () => IntegerKey,
-	IntegerPattern: () => IntegerPattern,
 	IntegerString: () => IntegerString,
-	Interface: () => Interface,
-	InterfaceAction: () => InterfaceAction,
-	InterfaceDeferred: () => InterfaceDeferred,
-	InterfaceInstantiate: () => InterfaceInstantiate,
 	Intersect: () => Intersect,
-	IntersectOptions: () => IntersectOptions,
-	InvalidLiteralValue: () => InvalidLiteralValue,
-	IsAny: () => IsAny,
-	IsArray: () => IsArray,
-	IsAsyncIterator: () => IsAsyncIterator,
-	IsBase: () => IsBase,
-	IsBigInt: () => IsBigInt,
-	IsBoolean: () => IsBoolean,
-	IsCall: () => IsCall,
-	IsCodec: () => IsCodec,
-	IsConstructor: () => IsConstructor,
-	IsCyclic: () => IsCyclic,
-	IsDeferred: () => IsDeferred,
-	IsDependent: () => IsDependent,
-	IsEnum: () => IsEnum,
-	IsFunction: () => IsFunction,
-	IsGeneric: () => IsGeneric,
-	IsIdentifier: () => IsIdentifier,
-	IsImmutable: () => IsImmutable,
-	IsInfer: () => IsInfer,
-	IsInteger: () => IsInteger,
-	IsInterfaceDeferred: () => IsInterfaceDeferred,
-	IsIntersect: () => IsIntersect,
-	IsIterator: () => IsIterator,
-	IsKind: () => IsKind,
-	IsLiteral: () => IsLiteral,
-	IsLiteralBigInt: () => IsLiteralBigInt,
-	IsLiteralBoolean: () => IsLiteralBoolean,
-	IsLiteralNumber: () => IsLiteralNumber,
-	IsLiteralString: () => IsLiteralString,
-	IsLiteralValue: () => IsLiteralValue,
-	IsNever: () => IsNever,
-	IsNull: () => IsNull,
-	IsNumber: () => IsNumber,
-	IsObject: () => IsObject,
-	IsOptional: () => IsOptional,
-	IsParameter: () => IsParameter,
-	IsPromise: () => IsPromise,
-	IsReadonly: () => IsReadonly,
-	IsRecord: () => IsRecord,
-	IsRef: () => IsRef,
-	IsRefine: () => IsRefine,
-	IsRefinement: () => IsRefinement,
-	IsRest: () => IsRest,
-	IsSchema: () => IsSchema,
-	IsString: () => IsString,
-	IsSymbol: () => IsSymbol,
-	IsTemplateLiteral: () => IsTemplateLiteral,
-	IsTemplateLiteralDeferred: () => IsTemplateLiteralDeferred,
-	IsTemplateLiteralFinite: () => IsTemplateLiteralFinite,
-	IsTemplateLiteralPattern: () => IsTemplateLiteralPattern,
-	IsThis: () => IsThis,
-	IsTuple: () => IsTuple,
-	IsTypeScriptEnumLike: () => IsTypeScriptEnumLike,
-	IsUndefined: () => IsUndefined,
-	IsUnion: () => IsUnion,
-	IsUnknown: () => IsUnknown,
-	IsUnsafe: () => IsUnsafe,
-	IsVoid: () => IsVoid,
-	Iterator: () => Iterator,
-	IteratorOptions: () => IteratorOptions,
-	KeyOf: () => KeyOf,
-	KeyOfAction: () => KeyOfAction,
-	KeyOfDeferred: () => KeyOfDeferred,
-	KeyOfInstantiate: () => KeyOfInstantiate,
-	KeysToIndexer: () => KeysToIndexer,
-	Literal: () => Literal,
-	LiteralTypeName: () => LiteralTypeName,
-	Lowercase: () => Lowercase,
-	LowercaseAction: () => LowercaseAction,
-	LowercaseDeferred: () => LowercaseDeferred,
-	LowercaseInstantiate: () => LowercaseInstantiate,
-	Mapped: () => Mapped,
-	MappedAction: () => MappedAction,
-	MappedDeferred: () => MappedDeferred,
-	MappedInstantiate: () => MappedInstantiate,
 	MaybeEmpty: () => MaybeEmpty,
-	Module: () => Module,
-	ModuleDeferred: () => ModuleDeferred,
-	ModuleInstantiate: () => ModuleInstantiate,
-	Narrow: () => Narrow,
-	Never: () => Never,
-	NeverPattern: () => NeverPattern,
 	NoValidate: () => NoValidate,
-	NonNullable: () => NonNullable,
-	NonNullableAction: () => NonNullableAction,
-	NonNullableDeferred: () => NonNullableDeferred,
-	NonNullableInstantiate: () => NonNullableInstantiate,
-	Null: () => Null,
 	Nullable: () => Nullable,
 	Number: () => NumberType,
-	NumberKey: () => NumberKey,
-	NumberPattern: () => NumberPattern,
 	Numeric: () => Numeric,
 	NumericEnum: () => NumericEnum,
 	Object: () => ObjectType,
-	ObjectOptions: () => ObjectOptions,
 	ObjectString: () => ObjectString,
-	Omit: () => Omit,
-	OmitAction: () => OmitAction,
-	OmitDeferred: () => OmitDeferred,
-	OmitInstantiate: () => OmitInstantiate,
 	Optional: () => Optional,
-	Options: () => Options,
-	Parameter: () => Parameter,
-	Parameters: () => Parameters,
-	ParametersAction: () => ParametersAction,
-	ParametersDeferred: () => ParametersDeferred,
-	ParametersInstantiate: () => ParametersInstantiate,
-	ParsePatternIntoTypes: () => ParsePatternIntoTypes,
-	ParseTemplateIntoTypes: () => ParseTemplateIntoTypes,
-	Partial: () => Partial,
-	PartialAction: () => PartialAction,
-	PartialDeferred: () => PartialDeferred,
-	PartialInstantiate: () => PartialInstantiate,
-	Pick: () => Pick,
-	PickAction: () => PickAction,
-	PickDeferred: () => PickDeferred,
-	PickInstantiate: () => PickInstantiate,
-	Priority: () => Priority,
-	Promise: () => Promise$1,
-	PromiseOptions: () => PromiseOptions,
-	PropertyKeys: () => PropertyKeys,
-	PropertyValues: () => PropertyValues,
-	Readonly: () => Readonly,
-	ReadonlyObject: () => ReadonlyObject,
-	ReadonlyObjectAction: () => ReadonlyObjectAction,
-	ReadonlyObjectDeferred: () => ReadonlyObjectDeferred,
-	ReadonlyObjectInstantiate: () => ReadonlyObjectInstantiate,
-	ReadonlyType: () => ReadonlyType,
-	Record: () => Record,
-	RecordAction: () => RecordAction,
-	RecordDeferred: () => RecordDeferred,
-	RecordFromPattern: () => RecordFromPattern,
-	RecordInstantiate: () => RecordInstantiate,
-	RecordKey: () => RecordKey,
-	RecordOptions: () => RecordOptions,
-	RecordPattern: () => RecordPattern,
-	RecordPatternToType: () => RecordPatternToType,
-	RecordValue: () => RecordValue,
-	Ref: () => Ref,
-	RefInstantiate: () => RefInstantiate,
-	Refine: () => Refine,
-	RefineAdd: () => RefineAdd,
-	RemoveImmutable: () => RemoveImmutable,
-	RemoveImmutableDeferred: () => RemoveImmutableDeferred,
-	RemoveOptional: () => RemoveOptional,
-	RemoveOptionalDeferred: () => RemoveOptionalDeferred,
-	RemoveReadonly: () => RemoveReadonly,
-	RemoveReadonlyDeferred: () => RemoveReadonlyDeferred,
-	Required: () => Required,
-	RequiredAction: () => RequiredAction,
-	RequiredArray: () => RequiredArray,
-	RequiredDeferred: () => RequiredDeferred,
-	RequiredInstantiate: () => RequiredInstantiate,
-	Rest: () => Rest,
-	ResultDisjoint: () => ResultDisjoint,
-	ResultEqual: () => ResultEqual,
-	ResultLeftInside: () => ResultLeftInside,
-	ResultRightInside: () => ResultRightInside,
-	ReturnType: () => ReturnType,
-	ReturnTypeAction: () => ReturnTypeAction,
-	ReturnTypeDeferred: () => ReturnTypeDeferred,
-	ReturnTypeInstantiate: () => ReturnTypeInstantiate,
-	Script: () => Script,
 	String: () => StringType,
-	StringKey: () => StringKey,
-	StringPattern: () => StringPattern,
-	Symbol: () => Symbol,
-	TemplateLiteral: () => TemplateLiteral,
-	TemplateLiteralCreate: () => TemplateLiteralCreate,
-	TemplateLiteralDecode: () => TemplateLiteralDecode,
-	TemplateLiteralDecodeUnsafe: () => TemplateLiteralDecodeUnsafe,
-	TemplateLiteralDeferred: () => TemplateLiteralDeferred,
-	TemplateLiteralEncode: () => TemplateLiteralEncode,
-	TemplateLiteralFromString: () => TemplateLiteralFromString,
-	TemplateLiteralFromTypes: () => TemplateLiteralFromTypes,
-	This: () => This,
-	Tuple: () => Tuple,
-	TupleOptions: () => TupleOptions,
-	TypeScriptEnumToEnumValues: () => TypeScriptEnumToEnumValues,
 	Uint8Array: () => Uint8ArrayType,
-	Uncapitalize: () => Uncapitalize,
-	UncapitalizeAction: () => UncapitalizeAction,
-	UncapitalizeDeferred: () => UncapitalizeDeferred,
-	UncapitalizeInstantiate: () => UncapitalizeInstantiate,
-	Undefined: () => Undefined,
 	Union: () => Union,
-	UnionEnum: () => UnionEnum,
-	UnionOptions: () => UnionOptions,
-	Unknown: () => Unknown,
-	Unsafe: () => Unsafe,
-	Uppercase: () => Uppercase,
-	UppercaseAction: () => UppercaseAction,
-	UppercaseDeferred: () => UppercaseDeferred,
-	UppercaseInstantiate: () => UppercaseInstantiate,
-	Void: () => Void,
-	With: () => With,
-	WithAction: () => WithAction,
-	WithDeferred: () => WithDeferred,
-	WithInstantiate: () => WithInstantiate,
-	_Array_: () => _Array_,
-	_Function_: () => _Function_,
-	_Object_: () => _Object_,
-	_Promise_: () => _Promise_
+	UnionEnum: () => UnionEnum
 });
+import * as import_typebox_type from "typebox/type";
+__reExport(exports_exports, import_typebox_type);
 setupTypebox();
 
 //#endregion
-export { Accelerate, AddImmutable, AddImmutableDeferred, AddOptional, AddOptionalDeferred, AddReadonly, AddReadonlyDeferred, Any, ArrayType as Array, ArrayBufferType as ArrayBuffer, ArrayOptions, ArrayString, AsyncIterator, AsyncIteratorOptions, Awaited, AwaitedAction, AwaitedDeferred, AwaitedInstantiate, Base, BigInt, BigIntPattern, BooleanType as Boolean, BooleanString, Broaden, Call, CallConstruct, Capitalize, CapitalizeAction, CapitalizeDeferred, CapitalizeInstantiate, Codec, CollapseToObject, Compare, Composite, Conditional, ConditionalAction, ConditionalDeferred, ConditionalInstantiate, Constructor, ConstructorOptions, ConstructorParameters, ConstructorParametersAction, ConstructorParametersDeferred, ConstructorParametersInstantiate, ConvertToIntegerKey, Cookie, Cyclic, CyclicCandidates, CyclicCheck, CyclicDependencies, CyclicExtends, CyclicOptions, CyclicTarget, DateType as Date, Decode, DecodeBuilder, Deferred, Dependent, DependentOptions, Distribute, Encode, EncodeBuilder, Enum, Evaluate, EvaluateAction, EvaluateDeferred, EvaluateDependent, EvaluateEnum, EvaluateInstantiate, EvaluateIntersect, EvaluateTemplateLiteral, EvaluateType, EvaluateUnion, EvaluateUnionFast, Exclude, ExcludeAction, ExcludeDeferred, ExcludeInstantiate, Extends, ExtendsResult, Extract, ExtractAction, ExtractDeferred, ExtractInstantiate, File, Files, Flatten, Form, Function, FunctionOptions, Generic, Identifier, Immutable, Index, IndexAction, IndexDeferred, IndexInstantiate, Infer, InstanceType, InstanceTypeAction, InstanceTypeDeferred, InstanceTypeInstantiate, Instantiate, InstantiateCyclic, Integer, IntegerKey, IntegerPattern, IntegerString, Interface, InterfaceAction, InterfaceDeferred, InterfaceInstantiate, Intersect, IntersectOptions, InvalidLiteralValue, IsAny, IsArray, IsAsyncIterator, IsBase, IsBigInt, IsBoolean, IsCall, IsCodec, IsConstructor, IsCyclic, IsDeferred, IsDependent, IsEnum, IsFunction, IsGeneric, IsIdentifier, IsImmutable, IsInfer, IsInteger, IsInterfaceDeferred, IsIntersect, IsIterator, IsKind, IsLiteral, IsLiteralBigInt, IsLiteralBoolean, IsLiteralNumber, IsLiteralString, IsLiteralValue, IsNever, IsNull, IsNumber, IsObject, IsOptional, IsParameter, IsPromise, IsReadonly, IsRecord, IsRef, IsRefine, IsRefinement, IsRest, IsSchema, IsString, IsSymbol, IsTemplateLiteral, IsTemplateLiteralDeferred, IsTemplateLiteralFinite, IsTemplateLiteralPattern, IsThis, IsTuple, IsTypeScriptEnumLike, IsUndefined, IsUnion, IsUnknown, IsUnsafe, IsVoid, Iterator, IteratorOptions, KeyOf, KeyOfAction, KeyOfDeferred, KeyOfInstantiate, KeysToIndexer, Literal, LiteralTypeName, Lowercase, LowercaseAction, LowercaseDeferred, LowercaseInstantiate, Mapped, MappedAction, MappedDeferred, MappedInstantiate, MaybeEmpty, Module, ModuleDeferred, ModuleInstantiate, Narrow, Never, NeverPattern, NoValidate, NonNullable, NonNullableAction, NonNullableDeferred, NonNullableInstantiate, Null, Nullable, NumberType as Number, NumberKey, NumberPattern, Numeric, NumericEnum, ObjectType as Object, ObjectOptions, ObjectString, Omit, OmitAction, OmitDeferred, OmitInstantiate, Optional, Options, Parameter, Parameters, ParametersAction, ParametersDeferred, ParametersInstantiate, ParsePatternIntoTypes, ParseTemplateIntoTypes, Partial, PartialAction, PartialDeferred, PartialInstantiate, Pick, PickAction, PickDeferred, PickInstantiate, Priority, Promise$1 as Promise, PromiseOptions, PropertyKeys, PropertyValues, Readonly, ReadonlyObject, ReadonlyObjectAction, ReadonlyObjectDeferred, ReadonlyObjectInstantiate, ReadonlyType, Record, RecordAction, RecordDeferred, RecordFromPattern, RecordInstantiate, RecordKey, RecordOptions, RecordPattern, RecordPatternToType, RecordValue, Ref, RefInstantiate, Refine, RefineAdd, RemoveImmutable, RemoveImmutableDeferred, RemoveOptional, RemoveOptionalDeferred, RemoveReadonly, RemoveReadonlyDeferred, Required, RequiredAction, RequiredArray, RequiredDeferred, RequiredInstantiate, Rest, ResultDisjoint, ResultEqual, ResultLeftInside, ResultRightInside, ReturnType, ReturnTypeAction, ReturnTypeDeferred, ReturnTypeInstantiate, Script, StringType as String, StringKey, StringPattern, Symbol, TemplateLiteral, TemplateLiteralCreate, TemplateLiteralDecode, TemplateLiteralDecodeUnsafe, TemplateLiteralDeferred, TemplateLiteralEncode, TemplateLiteralFromString, TemplateLiteralFromTypes, This, Tuple, TupleOptions, TypeScriptEnumToEnumValues, Uint8ArrayType as Uint8Array, Uncapitalize, UncapitalizeAction, UncapitalizeDeferred, UncapitalizeInstantiate, Undefined, Union, UnionEnum, UnionOptions, Unknown, Unsafe, Uppercase, UppercaseAction, UppercaseDeferred, UppercaseInstantiate, Void, With, WithAction, WithDeferred, WithInstantiate, _Array_, _Function_, _Object_, _Promise_, exports_exports };
+export { Accelerate, ArrayType as Array, ArrayBufferType as ArrayBuffer, ArrayString, BooleanType as Boolean, BooleanString, Cookie, DateType as Date, File, Files, Form, Integer, IntegerString, Intersect, MaybeEmpty, NoValidate, Nullable, NumberType as Number, Numeric, NumericEnum, ObjectType as Object, ObjectString, Optional, StringType as String, Uint8ArrayType as Uint8Array, Union, UnionEnum, exports_exports };

package/dist/type/index.d.ts

@@ -1,9 +1,13 @@
 import { AnySchema, BaseSchema, StandardJSONSchemaV1Like, StandardSchemaV1Like, TypeBoxSchema } from "./types.js";
 import { FileTypeDetector, fileType, setFileTypeDetector } from "./elysia/file-type.js";
 import { exports_d_exports } from "./exports.js";
+import { setupTypebox } from "./compat.js";
+import { TypeBoxValidator } from "./validator/index.js";
+import * as TypeBoxType from "typebox/type";
 import { System as TypeSystem } from "typebox/system";
 
 //#region src/type/index.d.ts
-declare const t: typeof exports_d_exports;
+type TypeBuilder = Omit<typeof TypeBoxType, keyof typeof exports_d_exports> & typeof exports_d_exports;
+declare const t: TypeBuilder;
 //#endregion
-export { type AnySchema, type BaseSchema, type FileTypeDetector, type StandardJSONSchemaV1Like, type StandardSchemaV1Like, type TypeBoxSchema, TypeSystem, fileType, setFileTypeDetector, t };
+export { type AnySchema, type BaseSchema, type FileTypeDetector, type StandardJSONSchemaV1Like, type StandardSchemaV1Like, type TypeBoxSchema, TypeBoxValidator, TypeSystem, fileType, setFileTypeDetector, setupTypebox, t };

package/dist/type/index.js

@@ -1,6 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.js');
 const require_type_elysia_file_type = require('./elysia/file-type.js');
+const require_type_validator_index = require('./validator/index.js');
+const require_type_compat = require('./compat.js');
 const require_type_exports = require('./exports.js');
 let typebox_system = require("typebox/system");
 
@@ -8,6 +10,7 @@ let typebox_system = require("typebox/system");
 const t = require_type_exports.exports_exports;
 
 //#endregion
+exports.TypeBoxValidator = require_type_validator_index.TypeBoxValidator;
 Object.defineProperty(exports, 'TypeSystem', {
   enumerable: true,
   get: function () {
@@ -16,4 +19,5 @@ Object.defineProperty(exports, 'TypeSystem', {
 });
 exports.fileType = require_type_elysia_file_type.fileType;
 exports.setFileTypeDetector = require_type_elysia_file_type.setFileTypeDetector;
+exports.setupTypebox = require_type_compat.setupTypebox;
 exports.t = t;

package/dist/type/index.mjs

@@ -1,4 +1,6 @@
 import { fileType, setFileTypeDetector } from "./elysia/file-type.mjs";
+import { TypeBoxValidator } from "./validator/index.mjs";
+import { setupTypebox } from "./compat.mjs";
 import { exports_exports } from "./exports.mjs";
 import { System as TypeSystem } from "typebox/system";
 
@@ -6,4 +8,4 @@ import { System as TypeSystem } from "typebox/system";
 const t = exports_exports;
 
 //#endregion
-export { TypeSystem, fileType, setFileTypeDetector, t };
+export { TypeBoxValidator, TypeSystem, fileType, setFileTypeDetector, setupTypebox, t };

package/dist/type/types.d.ts

@@ -1,9 +1,9 @@
 import { ELYSIA_TYPES } from "./constants.js";
 import { CookieOptions } from "../cookie/types.js";
 import { MaybeArray } from "../types.js";
-import { Validator } from "typebox/schema";
 import { TObjectOptions, TSchemaOptions } from "typebox";
 import { TLocalizedValidationError } from "typebox/error";
+import { Validator } from "typebox/schema";
 
 //#region src/type/types.d.ts
 type FileUnit = number | `${number}${'k' | 'm'}`;

package/dist/type/utils.js

@@ -27,11 +27,11 @@ function _hasTypes(types, schema) {
 		return _hasTypes(types, schema.items);
 	}
 	if (schema.properties) {
-		for (const v of Object.values(schema.properties)) if (_hasTypes(types, v)) return true;
+		for (const k in schema.properties) if (Object.hasOwn(schema.properties, k) && _hasTypes(types, schema.properties[k])) return true;
 	}
 	if (typeof schema.additionalProperties === "object" && _hasTypes(types, schema.additionalProperties)) return true;
 	if (schema.patternProperties) {
-		for (const v of Object.values(schema.patternProperties)) if (_hasTypes(types, v)) return true;
+		for (const k in schema.patternProperties) if (Object.hasOwn(schema.patternProperties, k) && _hasTypes(types, schema.patternProperties[k])) return true;
 	}
 	return false;
 }
@@ -45,11 +45,11 @@ function hasProperty(key, schema) {
 	if (schema.not && hasProperty(key, schema.not)) return true;
 	if (schema.items) return Array.isArray(schema.items) ? schema.items.some((s) => hasProperty(key, s)) : hasProperty(key, schema.items);
 	if (schema.properties) {
-		for (const v of Object.values(schema.properties)) if (hasProperty(key, v)) return true;
+		for (const k in schema.properties) if (Object.hasOwn(schema.properties, k) && hasProperty(key, schema.properties[k])) return true;
 	}
 	if (typeof schema.additionalProperties === "object" && hasProperty(key, schema.additionalProperties)) return true;
 	if (schema.patternProperties) {
-		for (const v of Object.values(schema.patternProperties)) if (hasProperty(key, v)) return true;
+		for (const k in schema.patternProperties) if (Object.hasOwn(schema.patternProperties, k) && hasProperty(key, schema.patternProperties[k])) return true;
 	}
 	return false;
 }

package/dist/type/utils.mjs

@@ -26,11 +26,11 @@ function _hasTypes(types, schema) {
 		return _hasTypes(types, schema.items);
 	}
 	if (schema.properties) {
-		for (const v of Object.values(schema.properties)) if (_hasTypes(types, v)) return true;
+		for (const k in schema.properties) if (Object.hasOwn(schema.properties, k) && _hasTypes(types, schema.properties[k])) return true;
 	}
 	if (typeof schema.additionalProperties === "object" && _hasTypes(types, schema.additionalProperties)) return true;
 	if (schema.patternProperties) {
-		for (const v of Object.values(schema.patternProperties)) if (_hasTypes(types, v)) return true;
+		for (const k in schema.patternProperties) if (Object.hasOwn(schema.patternProperties, k) && _hasTypes(types, schema.patternProperties[k])) return true;
 	}
 	return false;
 }
@@ -44,11 +44,11 @@ function hasProperty(key, schema) {
 	if (schema.not && hasProperty(key, schema.not)) return true;
 	if (schema.items) return Array.isArray(schema.items) ? schema.items.some((s) => hasProperty(key, s)) : hasProperty(key, schema.items);
 	if (schema.properties) {
-		for (const v of Object.values(schema.properties)) if (hasProperty(key, v)) return true;
+		for (const k in schema.properties) if (Object.hasOwn(schema.properties, k) && hasProperty(key, schema.properties[k])) return true;
 	}
 	if (typeof schema.additionalProperties === "object" && hasProperty(key, schema.additionalProperties)) return true;
 	if (schema.patternProperties) {
-		for (const v of Object.values(schema.patternProperties)) if (hasProperty(key, v)) return true;
+		for (const k in schema.patternProperties) if (Object.hasOwn(schema.patternProperties, k) && hasProperty(key, schema.patternProperties[k])) return true;
 	}
 	return false;
 }

package/dist/type/validator/custom-error.d.ts

@@ -0,0 +1,10 @@
+import { CapturedValidator, FrozenValidator } from "../../compile/aot.js";
+
+//#region src/type/validator/custom-error.d.ts
+declare function buildFindCustomError(schema: unknown, frozen?: FrozenValidator): ((value: unknown) => {
+  instancePath: string;
+  error: unknown;
+} | undefined) | undefined;
+declare function captureCustomErrors(schema: unknown): CapturedValidator['customErrors'] | undefined;
+//#endregion
+export { buildFindCustomError, captureCustomErrors };

package/dist/type/validator/custom-error.js

@@ -0,0 +1,113 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_compile_aot = require('../../compile/aot.js');
+const require_type_validator_frozen_check = require('./frozen-check.js');
+let typebox_schema = require("typebox/schema");
+
+//#region src/type/validator/custom-error.ts
+function collectCustomErrorNodes(schema, path, out, union) {
+	if (!schema || typeof schema !== "object") return out;
+	if (schema.error !== void 0) out.push({
+		path,
+		node: schema,
+		union
+	});
+	if (schema.properties) for (const k in schema.properties) collectCustomErrorNodes(schema.properties[k], path + "/" + k, out, union);
+	const items = schema.items;
+	if (Array.isArray(items)) for (let i = 0; i < items.length; i++) collectCustomErrorNodes(items[i], path + "/" + i, out, union);
+	else if (items && items.error !== void 0) out.push({
+		path,
+		node: items,
+		each: true,
+		union
+	});
+	const branches = schema.anyOf ?? schema.oneOf;
+	if (Array.isArray(branches)) {
+		const gate = {
+			node: schema,
+			path
+		};
+		for (const branch of branches) collectCustomErrorNodes(branch, path, out, gate);
+	}
+	return out;
+}
+function subValueAt(value, path) {
+	if (!path) return value;
+	let cur = value;
+	for (const part of path.split("/")) {
+		if (!part) continue;
+		if (cur === null || typeof cur !== "object") return;
+		cur = cur[part];
+	}
+	return cur;
+}
+function buildFindCustomError(schema, frozen) {
+	const nodes = collectCustomErrorNodes(schema, "", []);
+	if (!nodes.length) return;
+	const frozenByPath = frozen?.ce ? new Map(frozen.ce.map((e) => [e.p, e])) : void 0;
+	const checks = [];
+	for (const { path, node, each, union } of nodes) {
+		let check;
+		const fe = union ? void 0 : frozenByPath?.get(path);
+		if (fe) try {
+			check = fe.c(fe.e ? require_compile_aot.collectExternals(node) : require_compile_aot.EMPTY_EXTERNALS);
+		} catch {}
+		else try {
+			const c = (0, typebox_schema.Compile)(node);
+			check = (v) => c.Check(v);
+		} catch {}
+		if (check && each) {
+			const elementCheck = check;
+			check = (v) => !Array.isArray(v) || v.every((x) => elementCheck(x));
+		}
+		if (!check) continue;
+		let gate;
+		if (union) {
+			let unionCheck;
+			try {
+				const uc = (0, typebox_schema.Compile)(union.node);
+				unionCheck = (v) => uc.Check(v);
+			} catch {}
+			if (!unionCheck) continue;
+			const unionPath = union.path;
+			gate = (root) => unionCheck(subValueAt(root, unionPath));
+		}
+		checks.push({
+			path,
+			check,
+			gate,
+			error: node.error
+		});
+	}
+	if (!checks.length) return;
+	checks.sort((a, b) => b.path.length - a.path.length);
+	return (value) => {
+		for (const c of checks) {
+			if (c.gate && c.gate(value)) continue;
+			if (!c.check(subValueAt(value, c.path))) return {
+				instancePath: c.path,
+				error: c.error
+			};
+		}
+	};
+}
+function captureCustomErrors(schema) {
+	const ceNodes = collectCustomErrorNodes(schema, "", []);
+	if (!ceNodes.length) return;
+	const entries = [];
+	for (const { path, node, union } of ceNodes) {
+		if (union) continue;
+		try {
+			const cf = require_type_validator_frozen_check.buildFrozenCheck((0, typebox_schema.Build)(node), node);
+			if (cf) entries.push({
+				path,
+				...cf
+			});
+		} catch {}
+	}
+	return entries.length ? entries : void 0;
+}
+
+//#endregion
+exports.buildFindCustomError = buildFindCustomError;
+exports.captureCustomErrors = captureCustomErrors;