@sinclair/typebox 0.32.0-dev-5 → 0.32.0-dev-7

package/build/import/compiler/compiler.d.mts

@@ -0,0 +1,41 @@
+import { ValueErrorIterator } from '../errors/index.mjs';
+import type { TSchema } from '../type/schema/index.mjs';
+import type { Static, StaticDecode, StaticEncode } from '../type/static/index.mjs';
+export type CheckFunction = (value: unknown) => boolean;
+export declare class TypeCheck<T extends TSchema> {
+    private readonly schema;
+    private readonly references;
+    private readonly checkFunc;
+    private readonly code;
+    private readonly hasTransform;
+    constructor(schema: T, references: TSchema[], checkFunc: CheckFunction, code: string);
+    Code(): string;
+    Errors(value: unknown): ValueErrorIterator;
+    Check(value: unknown): value is Static<T>;
+    Decode(value: unknown): StaticDecode<T>;
+    Encode(value: unknown): StaticEncode<T>;
+}
+export declare class TypeCompilerUnknownTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare class TypeCompilerTypeGuardError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare namespace Policy {
+    function IsExactOptionalProperty(value: string, key: string, expression: string): string;
+    function IsObjectLike(value: string): string;
+    function IsRecordLike(value: string): string;
+    function IsNumberLike(value: string): string;
+    function IsVoidLike(value: string): string;
+}
+export type TypeCompilerLanguageOption = 'typescript' | 'javascript';
+export interface TypeCompilerCodegenOptions {
+    language?: TypeCompilerLanguageOption;
+}
+export declare namespace TypeCompiler {
+    function Code<T extends TSchema>(schema: T, references: TSchema[], options?: TypeCompilerCodegenOptions): string;
+    function Code<T extends TSchema>(schema: T, options?: TypeCompilerCodegenOptions): string;
+    function Compile<T extends TSchema>(schema: T, references?: TSchema[]): TypeCheck<T>;
+}

package/build/import/compiler/index.d.mts

@@ -0,0 +1,2 @@
+export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
+export * from './compiler.mjs';

package/build/import/errors/errors.d.mts

@@ -0,0 +1,86 @@
+import type { TSchema } from '../type/schema/index.mjs';
+export declare enum ValueErrorType {
+    ArrayContains = 0,
+    ArrayMaxContains = 1,
+    ArrayMaxItems = 2,
+    ArrayMinContains = 3,
+    ArrayMinItems = 4,
+    ArrayUniqueItems = 5,
+    Array = 6,
+    AsyncIterator = 7,
+    BigIntExclusiveMaximum = 8,
+    BigIntExclusiveMinimum = 9,
+    BigIntMaximum = 10,
+    BigIntMinimum = 11,
+    BigIntMultipleOf = 12,
+    BigInt = 13,
+    Boolean = 14,
+    DateExclusiveMaximumTimestamp = 15,
+    DateExclusiveMinimumTimestamp = 16,
+    DateMaximumTimestamp = 17,
+    DateMinimumTimestamp = 18,
+    DateMultipleOfTimestamp = 19,
+    Date = 20,
+    Function = 21,
+    IntegerExclusiveMaximum = 22,
+    IntegerExclusiveMinimum = 23,
+    IntegerMaximum = 24,
+    IntegerMinimum = 25,
+    IntegerMultipleOf = 26,
+    Integer = 27,
+    IntersectUnevaluatedProperties = 28,
+    Intersect = 29,
+    Iterator = 30,
+    Kind = 31,
+    Literal = 32,
+    Never = 33,
+    Not = 34,
+    Null = 35,
+    NumberExclusiveMaximum = 36,
+    NumberExclusiveMinimum = 37,
+    NumberMaximum = 38,
+    NumberMinimum = 39,
+    NumberMultipleOf = 40,
+    Number = 41,
+    ObjectAdditionalProperties = 42,
+    ObjectMaxProperties = 43,
+    ObjectMinProperties = 44,
+    ObjectRequiredProperty = 45,
+    Object = 46,
+    Promise = 47,
+    StringFormatUnknown = 48,
+    StringFormat = 49,
+    StringMaxLength = 50,
+    StringMinLength = 51,
+    StringPattern = 52,
+    String = 53,
+    Symbol = 54,
+    TupleLength = 55,
+    Tuple = 56,
+    Uint8ArrayMaxByteLength = 57,
+    Uint8ArrayMinByteLength = 58,
+    Uint8Array = 59,
+    Undefined = 60,
+    Union = 61,
+    Void = 62
+}
+export interface ValueError {
+    type: ValueErrorType;
+    schema: TSchema;
+    path: string;
+    value: unknown;
+    message: string;
+}
+export declare class ValueErrorsUnknownTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare function EscapeKey(key: string): string;
+export declare class ValueErrorIterator {
+    private readonly iterator;
+    constructor(iterator: IterableIterator<ValueError>);
+    [Symbol.iterator](): IterableIterator<ValueError>;
+    First(): ValueError | undefined;
+}
+export declare function Errors<T extends TSchema>(schema: T, references: TSchema[], value: unknown): ValueErrorIterator;
+export declare function Errors<T extends TSchema>(schema: T, value: unknown): ValueErrorIterator;

package/build/import/errors/index.d.mts

@@ -0,0 +1 @@
+export * from './errors.mjs';

package/build/import/index.d.mts

@@ -0,0 +1,68 @@
+export { Kind, Hint, ReadonlyKind, OptionalKind, TransformKind } from './type/symbols/index.mjs';
+export { PatternBoolean, PatternBooleanExact, PatternNumber, PatternNumberExact, PatternString, PatternStringExact } from './type/patterns/index.mjs';
+export { TypeRegistry, FormatRegistry } from './type/registry/index.mjs';
+export { TypeGuard, ValueGuard } from './type/guard/index.mjs';
+export { CloneType, CloneRest } from './type/clone/type.mjs';
+export { Clone } from './type/clone/value.mjs';
+export { Any, type TAny } from './type/any/index.mjs';
+export { Array, type TArray, type ArrayOptions } from './type/array/index.mjs';
+export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index.mjs';
+export { Awaited, type TAwaited } from './type/awaited/index.mjs';
+export { BigInt, type TBigInt, BigIntOptions } from './type/bigint/index.mjs';
+export { Boolean, type TBoolean } from './type/boolean/index.mjs';
+export { Composite, type TComposite } from './type/composite/index.mjs';
+export { Const, type TConst } from './type/const/index.mjs';
+export { Constructor, type TConstructor } from './type/constructor/index.mjs';
+export { ConstructorParameters, type TConstructorParameters } from './type/constructor-parameters/index.mjs';
+export { Date, type TDate, type DateOptions } from './type/date/index.mjs';
+export { Deref, type TDeref } from './type/deref/index.mjs';
+export { Enum, type TEnum } from './type/enum/index.mjs';
+export { Exclude, type TExclude } from './type/exclude/index.mjs';
+export { Extends, type TExtends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './type/extends/index.mjs';
+export { Extract, type TExtract } from './type/extract/index.mjs';
+export { Function, type TFunction } from './type/function/index.mjs';
+export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index.mjs';
+export { Index, type TIndex, IndexedKeyResolve, IndexedTypeResolve } from './type/indexed/index.mjs';
+export { InstanceType, type TInstanceType } from './type/instance-type/index.mjs';
+export { Integer, type TInteger, type IntegerOptions } from './type/integer/index.mjs';
+export { Intersect, type TIntersect, type IntersectOptions } from './type/intersect/index.mjs';
+export { Iterator, type TIterator } from './type/iterator/index.mjs';
+export { Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase, IntrinsicResolve } from './type/intrinsic/index.mjs';
+export { KeyOf, type TKeyOf, KeyOfStringResolve, KeyOfStringResolvePattern, KeyOfTypeResolve } from './type/keyof/index.mjs';
+export { Literal, type TLiteral } from './type/literal/index.mjs';
+export { Mapped, type TMappedKey, type MappedFunction, type TMappedResult } from './type/mapped/index.mjs';
+export { Never, type TNever } from './type/never/index.mjs';
+export { Not, type TNot } from './type/not/index.mjs';
+export { Null, type TNull } from './type/null/index.mjs';
+export { Number, type TNumber, type NumberOptions } from './type/number/index.mjs';
+export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index.mjs';
+export { Omit, type TOmit } from './type/omit/index.mjs';
+export { Optional, type TOptional } from './type/optional/index.mjs';
+export { Parameters, type TParameters } from './type/parameters/index.mjs';
+export { Partial, type TPartial } from './type/partial/index.mjs';
+export { Pick, type TPick } from './type/pick/index.mjs';
+export { Promise, type TPromise } from './type/promise/index.mjs';
+export { Readonly, type TReadonly } from './type/readonly/index.mjs';
+export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index.mjs';
+export { Record, type TRecord } from './type/record/index.mjs';
+export { Recursive, type TRecursive, type TThis } from './type/recursive/index.mjs';
+export { Ref, type TRef } from './type/ref/index.mjs';
+export { RegExp, type TRegExp } from './type/regexp/index.mjs';
+export { Required, type TRequired } from './type/required/index.mjs';
+export { Rest, type TRest } from './type/rest/index.mjs';
+export { ReturnType, type TReturnType } from './type/return-type/index.mjs';
+export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from './type/schema/index.mjs';
+export { type Static, type StaticDecode, type StaticEncode } from './type/static/index.mjs';
+export { Strict } from './type/strict/index.mjs';
+export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index.mjs';
+export { Symbol, type TSymbol, type SymbolValue } from './type/symbol/index.mjs';
+export { TemplateLiteral, IsTemplateLiteralFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, type TTemplateLiteral, type TTemplateLiteralKind } from './type/template-literal/index.mjs';
+export { Transform, type TTransform, type TransformOptions, type TransformFunction, TransformDecodeBuilder, TransformEncodeBuilder } from './type/transform/index.mjs';
+export { Tuple, type TTuple } from './type/tuple/index.mjs';
+export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index.mjs';
+export { Undefined, type TUndefined } from './type/undefined/index.mjs';
+export { Union, type TUnion } from './type/union/index.mjs';
+export { Unknown, type TUnknown } from './type/unknown/index.mjs';
+export { Unsafe, type TUnsafe } from './type/unsafe/index.mjs';
+export { Void, type TVoid } from './type/void/index.mjs';
+export { Type, JsonTypeBuilder, JavaScriptTypeBuilder } from './type/type/index.mjs';

package/build/import/index.mjs

@@ -63,7 +63,4 @@ export { Union } from './type/union/index.mjs';
 export { Unknown } from './type/unknown/index.mjs';
 export { Unsafe } from './type/unsafe/index.mjs';
 export { Void } from './type/void/index.mjs';
-export { JsonTypeBuilder, JavaScriptTypeBuilder } from './type/type/index.mjs';
-import { Type } from './type/type/index.mjs';
-export { Type };
-export default Type;
+export { Type, JsonTypeBuilder, JavaScriptTypeBuilder } from './type/type/index.mjs';

package/build/import/system/errors.d.mts

@@ -0,0 +1,9 @@
+import { ValueErrorType } from '../errors/errors.mjs';
+import { TSchema } from '../type/schema/index.mjs';
+export type ErrorFunction = (schema: TSchema, type: ValueErrorType) => string;
+export declare namespace TypeSystemErrorFunction {
+    function Reset(): void;
+    function Set(callback: ErrorFunction): void;
+    function Get(): ErrorFunction;
+}
+export declare function DefaultErrorFunction(schema: TSchema, errorType: ValueErrorType): string;

package/build/import/system/index.d.mts

@@ -0,0 +1,4 @@
+export { ValueErrorType } from '../errors/errors.mjs';
+export { DefaultErrorFunction, ErrorFunction, TypeSystemErrorFunction } from './errors.mjs';
+export { TypeSystemPolicy } from './policy.mjs';
+export { TypeSystem, TypeSystemDuplicateFormat, TypeSystemDuplicateTypeKind } from './system.mjs';

package/build/import/system/system.d.mts

@@ -0,0 +1,10 @@
+export declare class TypeSystemDuplicateTypeKind extends Error {
+    constructor(kind: string);
+}
+export declare class TypeSystemDuplicateFormat extends Error {
+    constructor(kind: string);
+}
+export declare namespace TypeSystem {
+    function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => import("../type/unsafe/unsafe.mjs").TUnsafe<Type>;
+    function Format<F extends string>(format: F, check: (value: string) => boolean): F;
+}

package/build/import/type/any/any.d.mts

@@ -0,0 +1,7 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TAny extends TSchema {
+    [Kind]: 'Any';
+    static: any;
+}
+export declare function Any(options?: SchemaOptions): TAny;

package/build/import/type/any/index.d.mts

@@ -0,0 +1 @@
+export * from './any.mjs';

package/build/import/type/array/array.d.mts

@@ -0,0 +1,18 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface ArrayOptions extends SchemaOptions {
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    contains?: TSchema;
+    minContains?: number;
+    maxContains?: number;
+}
+export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
+    [Kind]: 'Array';
+    static: Static<T, this['params']>[];
+    type: 'array';
+    items: T;
+}
+export declare function Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;

package/build/import/type/array/index.d.mts

@@ -0,0 +1 @@
+export * from './array.mjs';

package/build/import/type/async-iterator/async-iterator.d.mts

@@ -0,0 +1,10 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'AsyncIterator';
+    static: AsyncIterableIterator<Static<T, this['params']>>;
+    type: 'AsyncIterator';
+    items: T;
+}
+export declare function AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;

package/build/import/type/async-iterator/index.d.mts

@@ -0,0 +1 @@
+export * from './async-iterator.mjs';

package/build/import/type/awaited/awaited.d.mts

@@ -0,0 +1,11 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TPromise } from '../promise/index.mjs';
+type AwaitedUnwrap<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [AwaitedResolve<L>, ...AwaitedUnwrap<R>] : [];
+declare function AwaitedUnwrap<T extends TSchema[]>(T: [...T]): AwaitedUnwrap<T>;
+export type AwaitedResolve<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<AwaitedUnwrap<S>> : T extends TUnion<infer S> ? TUnion<AwaitedUnwrap<S>> : T extends TPromise<infer S> ? AwaitedResolve<S> : T;
+export declare function Resolve<T extends TSchema>(T: T): AwaitedResolve<T>;
+export type TAwaited<T extends TSchema> = AwaitedResolve<T>;
+export declare function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): AwaitedResolve<T>;
+export {};

package/build/import/type/awaited/index.d.mts

@@ -0,0 +1 @@
+export * from './awaited.mjs';

package/build/import/type/bigint/bigint.d.mts

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface BigIntOptions extends SchemaOptions {
+    exclusiveMaximum?: bigint;
+    exclusiveMinimum?: bigint;
+    maximum?: bigint;
+    minimum?: bigint;
+    multipleOf?: bigint;
+}
+export interface TBigInt extends TSchema, BigIntOptions {
+    [Kind]: 'BigInt';
+    static: bigint;
+    type: 'bigint';
+}
+export declare function BigInt(options?: BigIntOptions): TBigInt;

package/build/import/type/bigint/index.d.mts

@@ -0,0 +1 @@
+export * from './bigint.mjs';

package/build/import/type/boolean/boolean.d.mts

@@ -0,0 +1,8 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TBoolean extends TSchema {
+    [Kind]: 'Boolean';
+    static: boolean;
+    type: 'boolean';
+}
+export declare function Boolean(options?: SchemaOptions): TBoolean;

package/build/import/type/boolean/index.d.mts

@@ -0,0 +1 @@
+export * from './boolean.mjs';

package/build/import/type/clone/index.d.mts

@@ -0,0 +1,2 @@
+export * as TypeClone from './type.mjs';
+export * as ValueClone from './value.mjs';

package/build/import/type/clone/type.d.mts

@@ -0,0 +1,3 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+export declare function CloneRest<T extends TSchema[]>(schemas: T): T;
+export declare function CloneType<T extends TSchema>(schema: T, options?: SchemaOptions): T;

package/build/import/type/composite/composite.d.mts

@@ -0,0 +1,14 @@
+import type { UnionToTuple, Assert, Evaluate } from '../helpers/index.mjs';
+import { type TObject, type ObjectOptions } from '../object/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { IndexedTypeResolve } from '../indexed/index.mjs';
+type CompositeKeys<T extends TObject[]> = T extends [infer L extends TObject, ...infer R extends TObject[]] ? keyof L['properties'] | CompositeKeys<R> : never;
+type CompositeIndex<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L extends string, ...infer R extends string[]] ? {
+    [_ in L]: IndexedTypeResolve<T, [L]>;
+} & CompositeIndex<T, R> : {};
+type CompositeReduce<T extends TObject[]> = UnionToTuple<CompositeKeys<T>> extends infer K ? Evaluate<CompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
+export type CompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<CompositeReduce<T>> : TObject<{}>;
+export declare function CompositeResolve<T extends TObject[]>(T: [...T]): CompositeResolve<T>;
+export type TComposite<T extends TObject[]> = CompositeResolve<T>;
+export declare function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T>;
+export {};

package/build/import/type/composite/index.d.mts

@@ -0,0 +1 @@
+export * from './composite.mjs';

package/build/import/type/const/const.d.mts

@@ -0,0 +1,29 @@
+import type { AssertRest, Evaluate } from '../helpers/index.mjs';
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TAny } from '../any/index.mjs';
+import { type TBigInt } from '../bigint/index.mjs';
+import { type TDate } from '../date/index.mjs';
+import { type TFunction } from '../function/index.mjs';
+import { type TLiteral } from '../literal/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TNull } from '../null/index.mjs';
+import { type TObject } from '../object/index.mjs';
+import { type TSymbol } from '../symbol/index.mjs';
+import { type TTuple } from '../tuple/index.mjs';
+import { type TReadonly } from '../readonly/index.mjs';
+import { type TUndefined } from '../undefined/index.mjs';
+import { type TUint8Array } from '../uint8array/index.mjs';
+import { type TUnknown } from '../unknown/index.mjs';
+type FromArray<T extends readonly unknown[]> = T extends readonly [infer L extends unknown, ...infer R extends unknown[]] ? [FromValue<L, false>, ...FromArray<R>] : T;
+declare function FromArray<T extends readonly unknown[]>(T: [...T]): FromArray<T>;
+type FromProperties<T extends Record<PropertyKey, unknown>> = {
+    -readonly [K in keyof T]: FromValue<T[K], false> extends infer R extends TSchema ? TReadonly<R> : TReadonly<TNever>;
+};
+declare function FromProperties<T extends Record<PropertyKey, unknown>>(value: T): FromProperties<T>;
+type ConditionalReadonly<T extends TSchema, Root extends boolean> = Root extends true ? T : TReadonly<T>;
+declare function ConditionalReadonly<T extends TSchema, Root extends boolean>(T: T, root: Root): ConditionalReadonly<T, Root>;
+type FromValue<T, Root extends boolean> = T extends AsyncIterableIterator<unknown> ? ConditionalReadonly<TAny, Root> : T extends IterableIterator<unknown> ? ConditionalReadonly<TAny, Root> : T extends readonly unknown[] ? TReadonly<TTuple<AssertRest<FromArray<T>>>> : T extends Uint8Array ? TUint8Array : T extends Date ? TDate : T extends Record<PropertyKey, unknown> ? ConditionalReadonly<TObject<Evaluate<FromProperties<T>>>, Root> : T extends Function ? ConditionalReadonly<TFunction<[], TUnknown>, Root> : T extends undefined ? TUndefined : T extends null ? TNull : T extends symbol ? TSymbol : T extends number ? TLiteral<T> : T extends boolean ? TLiteral<T> : T extends string ? TLiteral<T> : T extends bigint ? TBigInt : TObject<{}>;
+declare function FromValue<T, Root extends boolean>(value: T, root: Root): FromValue<T, Root>;
+export type TConst<T> = FromValue<T, true>;
+export declare function Const<T>(T: T, options?: SchemaOptions): TConst<T>;
+export {};

package/build/import/type/const/index.d.mts

@@ -0,0 +1 @@
+export * from './const.mjs';

package/build/import/type/constructor/constructor.d.mts

@@ -0,0 +1,16 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import type { Ensure } from '../helpers/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+type TConstructorReturnTypeResolve<T extends TSchema, P extends unknown[]> = Static<T, P>;
+type TConstructorParametersResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TConstructorParametersResolve<R, P>] : [];
+export type TConstructorResolve<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: TConstructorParametersResolve<T, P>) => TConstructorReturnTypeResolve<U, P>>);
+export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Constructor';
+    static: TConstructorResolve<T, U, this['params']>;
+    type: 'Constructor';
+    parameters: T;
+    returns: U;
+}
+export declare function Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
+export {};

package/build/import/type/constructor/index.d.mts

@@ -0,0 +1 @@
+export * from './constructor.mjs';

package/build/import/type/constructor-parameters/constructor-parameters.d.mts

@@ -0,0 +1,6 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Ensure } from '../helpers/index.mjs';
+import type { TConstructor } from '../constructor/index.mjs';
+import { type TTuple } from '../tuple/index.mjs';
+export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = (Ensure<TTuple<T['parameters']>>);
+export declare function ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;

package/build/import/type/constructor-parameters/index.d.mts

@@ -0,0 +1 @@
+export * from './constructor-parameters.mjs';

package/build/import/type/date/date.d.mts

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface DateOptions extends SchemaOptions {
+    exclusiveMaximumTimestamp?: number;
+    exclusiveMinimumTimestamp?: number;
+    maximumTimestamp?: number;
+    minimumTimestamp?: number;
+    multipleOfTimestamp?: number;
+}
+export interface TDate extends TSchema, DateOptions {
+    [Kind]: 'Date';
+    static: Date;
+    type: 'date';
+}
+export declare function Date(options?: DateOptions): TDate;

package/build/import/type/date/index.d.mts

@@ -0,0 +1 @@
+export * from './date.mjs';

package/build/import/type/deref/deref.d.mts

@@ -0,0 +1,23 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { Evaluate } from '../helpers/index.mjs';
+import type { TTuple } from '../tuple/index.mjs';
+import type { TIntersect } from '../intersect/index.mjs';
+import type { TUnion } from '../union/index.mjs';
+import type { TPromise } from '../promise/index.mjs';
+import type { TAsyncIterator } from '../async-iterator/index.mjs';
+import type { TIterator } from '../iterator/index.mjs';
+import type { TArray } from '../array/index.mjs';
+import type { TConstructor } from '../constructor/index.mjs';
+import type { TFunction } from '../function/index.mjs';
+import type { TRef } from '../ref/index.mjs';
+import type { TObject, TProperties } from '../object/index.mjs';
+export type FromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [DerefResolve<L>, ...FromRest<R>] : []);
+type FromProperties<T extends TProperties> = Evaluate<{
+    [K in keyof T]: DerefResolve<T[K]>;
+}>;
+declare function FromProperties(properties: TProperties, references: TSchema[]): TProperties;
+export type DerefResolve<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<FromRest<S>, DerefResolve<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<FromRest<S>, DerefResolve<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<FromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<FromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<FromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<DerefResolve<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<DerefResolve<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DerefResolve<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DerefResolve<S>> : T extends TRef<infer S extends TSchema> ? DerefResolve<S> : T;
+export declare function DerefResolve<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
+export type TDeref<T extends TSchema> = DerefResolve<T>;
+export declare function Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
+export {};

package/build/import/type/deref/index.d.mts

@@ -0,0 +1 @@
+export * from './deref.mjs';

package/build/import/type/discard/index.d.mts

@@ -0,0 +1 @@
+export * from './discard.mjs';

package/build/import/type/enum/enum.d.mts

@@ -0,0 +1,13 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TLiteral } from '../literal/index.mjs';
+import { Kind, Hint } from '../symbols/index.mjs';
+export type TEnumRecord = Record<TEnumKey, TEnumValue>;
+export type TEnumValue = string | number;
+export type TEnumKey = string;
+export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
+    [Kind]: 'Union';
+    [Hint]: 'Enum';
+    static: T[keyof T];
+    anyOf: TLiteral<T[keyof T]>[];
+}
+export declare function Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;

package/build/import/type/enum/index.d.mts

@@ -0,0 +1 @@
+export * from './enum.mjs';

package/build/import/type/exclude/exclude.d.mts

@@ -0,0 +1,20 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { UnionToTuple, AssertRest, AssertType, Assert } from '../helpers/index.mjs';
+import { type TTemplateLiteral } from '../template-literal/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TLiteral } from '../literal/index.mjs';
+import { type Static } from '../static/index.mjs';
+import { UnionResolve } from '../union/index.mjs';
+type ExcludeTemplateLiteralResult<T extends string> = UnionResolve<AssertRest<UnionToTuple<{
+    [K in T]: TLiteral<K>;
+}[T]>>>;
+type ExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = (Exclude<Static<T>, Static<U>> extends infer S ? ExcludeTemplateLiteralResult<Assert<S, string>> : never);
+type ExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
+    [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K];
+}[number]>> extends infer R extends TSchema[] ? UnionResolve<R> : never;
+type ExcludeResolve<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? ExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? ExcludeArray<S, U> : T extends U ? TNever : T;
+export declare function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExcludeResolve<L, R>;
+export type TExclude<T extends TSchema, U extends TSchema> = ExcludeResolve<T, U>;
+export declare function Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
+export {};

package/build/import/type/exclude/index.d.mts

@@ -0,0 +1 @@
+export * from './exclude.mjs';

package/build/import/type/extends/extends-check.d.mts

@@ -0,0 +1,9 @@
+import { type TSchema } from '../schema/index.mjs';
+export declare class ExtendsResolverError extends Error {
+}
+export declare enum ExtendsResult {
+    Union = 0,
+    True = 1,
+    False = 2
+}
+export declare function ExtendsCheck(left: TSchema, right: TSchema): ExtendsResult;

package/build/import/type/extends/extends-undefined.d.mts

@@ -0,0 +1,2 @@
+import type { TSchema } from '../schema/index.mjs';
+export declare function ExtendsUndefinedCheck(schema: TSchema): boolean;

package/build/import/type/extends/extends.d.mts

@@ -0,0 +1,8 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { UnionToTuple } from '../helpers/index.mjs';
+export type ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = ((Static<L> extends Static<R> ? T : U) extends infer O extends TSchema ? UnionToTuple<O> extends [infer X extends TSchema, infer Y extends TSchema] ? TUnion<[X, Y]> : O : never);
+export declare function ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U): ExtendsResolve<L, R, T, U>;
+export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema> = ExtendsResolve<L, R, T, F>;
+export declare function Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;

package/build/import/type/extends/index.d.mts

@@ -0,0 +1,3 @@
+export * from './extends-check.mjs';
+export * from './extends-undefined.mjs';
+export * from './extends.mjs';

package/build/import/type/extract/extract.d.mts

@@ -0,0 +1,19 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Assert, AssertRest, AssertType, UnionToTuple } from '../helpers/index.mjs';
+import { type TTemplateLiteral } from '../template-literal/index.mjs';
+import { type TLiteral } from '../literal/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type Static } from '../static/index.mjs';
+import { UnionResolve } from '../union/index.mjs';
+type FromTemplateLiteralResult<T extends string> = UnionResolve<AssertRest<UnionToTuple<{
+    [K in T]: TLiteral<K>;
+}[T]>>>;
+type FromTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? FromTemplateLiteralResult<Assert<S, string>> : never;
+type FromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
+    [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never;
+}[number]>> extends infer R extends TSchema[] ? UnionResolve<R> : never;
+export type ExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T, U> : T extends TUnion<infer S> ? FromArray<S, U> : T extends U ? T : T);
+export declare function ExtractResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExtractResolve<L, R>;
+export type TExtract<T extends TSchema, U extends TSchema> = ExtractResolve<T, U>;
+export declare function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
+export {};

package/build/import/type/extract/index.d.mts

@@ -0,0 +1 @@
+export * from './extract.mjs';

package/build/import/type/function/function.d.mts

@@ -0,0 +1,16 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import type { Ensure } from '../helpers/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+type FunctionReturnTypeResolve<T extends TSchema, P extends unknown[]> = Static<T, P>;
+type FunctionParametersResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...FunctionParametersResolve<R, P>] : [];
+type FunctionResolve<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<(...param: FunctionParametersResolve<T, P>) => FunctionReturnTypeResolve<U, P>>);
+export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Function';
+    static: FunctionResolve<T, U, this['params']>;
+    type: 'Function';
+    parameters: T;
+    returns: U;
+}
+export declare function Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
+export {};

package/build/import/type/function/index.d.mts

@@ -0,0 +1 @@
+export * from './function.mjs';

package/build/import/type/guard/index.d.mts

@@ -0,0 +1,2 @@
+export * as TypeGuard from './type.mjs';
+export * as ValueGuard from './value.mjs';