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

package/build/types/index.d.ts

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

package/build/types/system/errors.d.ts

@@ -0,0 +1,9 @@
+import { ValueErrorType } from '../errors/errors';
+import { TSchema } from '../type/schema/index';
+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/types/system/index.d.ts

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

package/build/types/system/policy.d.ts

@@ -0,0 +1,11 @@
+export declare namespace TypeSystemPolicy {
+    let ExactOptionalPropertyTypes: boolean;
+    let AllowArrayObject: boolean;
+    let AllowNaN: boolean;
+    let AllowNullVoid: boolean;
+    function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string): boolean;
+    function IsObjectLike(value: unknown): value is Record<keyof any, unknown>;
+    function IsRecordLike(value: unknown): value is Record<keyof any, unknown>;
+    function IsNumberLike(value: unknown): value is number;
+    function IsVoidLike(value: unknown): value is void;
+}

package/build/types/system/system.d.ts

@@ -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").TUnsafe<Type>;
+    function Format<F extends string>(format: F, check: (value: string) => boolean): F;
+}

package/build/types/type/any/any.d.ts

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

package/build/types/type/any/index.d.ts

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

package/build/types/type/array/array.d.ts

@@ -0,0 +1,18 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+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/types/type/array/index.d.ts

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

package/build/types/type/async-iterator/async-iterator.d.ts

@@ -0,0 +1,10 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+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/types/type/async-iterator/index.d.ts

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

package/build/types/type/awaited/awaited.d.ts

@@ -0,0 +1,11 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { type TIntersect } from '../intersect/index';
+import { type TUnion } from '../union/index';
+import { type TPromise } from '../promise/index';
+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/types/type/awaited/index.d.ts

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

package/build/types/type/bigint/bigint.d.ts

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+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/types/type/bigint/index.d.ts

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

package/build/types/type/boolean/boolean.d.ts

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

package/build/types/type/boolean/index.d.ts

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

package/build/types/type/clone/index.d.ts

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

package/build/types/type/clone/type.d.ts

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

package/build/types/type/clone/value.d.ts

@@ -0,0 +1 @@
+export declare function Clone<T>(value: T): T;

package/build/types/type/composite/composite.d.ts

@@ -0,0 +1,14 @@
+import type { UnionToTuple, Assert, Evaluate } from '../helpers/index';
+import { type TObject, type ObjectOptions } from '../object/index';
+import { type TIntersect } from '../intersect/index';
+import { IndexedTypeResolve } from '../indexed/index';
+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/types/type/composite/index.d.ts

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

package/build/types/type/const/const.d.ts

@@ -0,0 +1,29 @@
+import type { AssertRest, Evaluate } from '../helpers/index';
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { type TAny } from '../any/index';
+import { type TBigInt } from '../bigint/index';
+import { type TDate } from '../date/index';
+import { type TFunction } from '../function/index';
+import { type TLiteral } from '../literal/index';
+import { type TNever } from '../never/index';
+import { type TNull } from '../null/index';
+import { type TObject } from '../object/index';
+import { type TSymbol } from '../symbol/index';
+import { type TTuple } from '../tuple/index';
+import { type TReadonly } from '../readonly/index';
+import { type TUndefined } from '../undefined/index';
+import { type TUint8Array } from '../uint8array/index';
+import { type TUnknown } from '../unknown/index';
+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/types/type/const/index.d.ts

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

package/build/types/type/constructor/constructor.d.ts

@@ -0,0 +1,16 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import type { Ensure } from '../helpers/index';
+import { Kind } from '../symbols/index';
+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/types/type/constructor/index.d.ts

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

package/build/types/type/constructor-parameters/constructor-parameters.d.ts

@@ -0,0 +1,6 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Ensure } from '../helpers/index';
+import type { TConstructor } from '../constructor/index';
+import { type TTuple } from '../tuple/index';
+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/types/type/constructor-parameters/index.d.ts

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

package/build/types/type/date/date.d.ts

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+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/types/type/date/index.d.ts

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

package/build/types/type/deref/deref.d.ts

@@ -0,0 +1,23 @@
+import type { TSchema } from '../schema/index';
+import type { Evaluate } from '../helpers/index';
+import type { TTuple } from '../tuple/index';
+import type { TIntersect } from '../intersect/index';
+import type { TUnion } from '../union/index';
+import type { TPromise } from '../promise/index';
+import type { TAsyncIterator } from '../async-iterator/index';
+import type { TIterator } from '../iterator/index';
+import type { TArray } from '../array/index';
+import type { TConstructor } from '../constructor/index';
+import type { TFunction } from '../function/index';
+import type { TRef } from '../ref/index';
+import type { TObject, TProperties } from '../object/index';
+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/types/type/deref/index.d.ts

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

package/build/types/type/discard/index.d.ts

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

package/build/types/type/enum/enum.d.ts

@@ -0,0 +1,13 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { type TLiteral } from '../literal/index';
+import { Kind, Hint } from '../symbols/index';
+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/types/type/enum/index.d.ts

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

package/build/types/type/exclude/exclude.d.ts

@@ -0,0 +1,20 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { UnionToTuple, AssertRest, AssertType, Assert } from '../helpers/index';
+import { type TTemplateLiteral } from '../template-literal/index';
+import { type TUnion } from '../union/index';
+import { type TNever } from '../never/index';
+import { type TLiteral } from '../literal/index';
+import { type Static } from '../static/index';
+import { UnionResolve } from '../union/index';
+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/types/type/exclude/index.d.ts

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

package/build/types/type/extends/extends-check.d.ts

@@ -0,0 +1,9 @@
+import { type TSchema } from '../schema/index';
+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/types/type/extends/extends-undefined.d.ts

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

package/build/types/type/extends/extends.d.ts

@@ -0,0 +1,8 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { type TUnion } from '../union/index';
+import { UnionToTuple } from '../helpers/index';
+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/types/type/extends/index.d.ts

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

package/build/types/type/extract/extract.d.ts

@@ -0,0 +1,19 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Assert, AssertRest, AssertType, UnionToTuple } from '../helpers/index';
+import { type TTemplateLiteral } from '../template-literal/index';
+import { type TLiteral } from '../literal/index';
+import { type TUnion } from '../union/index';
+import { type Static } from '../static/index';
+import { UnionResolve } from '../union/index';
+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/types/type/extract/index.d.ts

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

package/build/types/type/function/function.d.ts

@@ -0,0 +1,16 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import type { Ensure } from '../helpers/index';
+import { Kind } from '../symbols/index';
+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/types/type/function/index.d.ts

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

package/build/types/type/guard/index.d.ts

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

package/build/types/type/guard/type.d.ts

@@ -0,0 +1,88 @@
+import { Kind, Hint, TransformKind } from '../symbols/index';
+import type { TransformOptions } from '../transform/index';
+import type { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index';
+import type { TArray } from '../array/index';
+import type { TBoolean } from '../boolean/index';
+import type { TRecord } from '../record/index';
+import type { TString } from '../string/index';
+import type { TUnion } from '../union/index';
+import type { TAny } from '../any/index';
+import type { TAsyncIterator } from '../async-iterator/index';
+import type { TBigInt } from '../bigint/index';
+import type { TConstructor } from '../constructor/index';
+import type { TFunction } from '../function/index';
+import type { TInteger } from '../integer/index';
+import type { TIntersect } from '../intersect/index';
+import type { TIterator } from '../iterator/index';
+import type { TLiteral } from '../literal/index';
+import type { TNever } from '../never/index';
+import type { TNot } from '../not/index';
+import type { TNull } from '../null/index';
+import type { TNumber } from '../number/index';
+import type { TObject } from '../object/index';
+import type { TOptional } from '../optional/index';
+import type { TPromise } from '../promise/index';
+import type { TReadonly } from '../readonly/index';
+import type { TRef } from '../ref/index';
+import type { TSchema } from '../schema/index';
+import type { TSymbol } from '../symbol/index';
+import type { TTuple } from '../tuple/index';
+import type { TUint8Array } from '../uint8array/index';
+import type { TUndefined } from '../undefined/index';
+import type { TUnknown } from '../unknown/index';
+import type { TUnsafe } from '../unsafe/index';
+import type { TVoid } from '../void/index';
+import type { TDate } from '../date/index';
+import type { TThis } from '../recursive/index';
+export declare class TypeGuardUnknownTypeError extends Error {
+}
+export declare function TReadonly<T extends TSchema>(schema: T): schema is TReadonly<T>;
+export declare function TOptional<T extends TSchema>(schema: T): schema is TOptional<T>;
+export declare function TAny(schema: unknown): schema is TAny;
+export declare function TArray(schema: unknown): schema is TArray;
+export declare function TAsyncIterator(schema: unknown): schema is TAsyncIterator;
+export declare function TBigInt(schema: unknown): schema is TBigInt;
+export declare function TBoolean(schema: unknown): schema is TBoolean;
+export declare function TConstructor(schema: unknown): schema is TConstructor;
+export declare function TDate(schema: unknown): schema is TDate;
+export declare function TFunction(schema: unknown): schema is TFunction;
+export declare function TInteger(schema: unknown): schema is TInteger;
+export declare function TIntersect(schema: unknown): schema is TIntersect;
+export declare function TIterator(schema: unknown): schema is TIterator;
+export declare function TKindOf<T extends string>(schema: unknown, kind: T): schema is Record<PropertyKey, unknown> & {
+    [Kind]: T;
+};
+export declare function TLiteralString(schema: unknown): schema is TLiteral<string>;
+export declare function TLiteralNumber(schema: unknown): schema is TLiteral<number>;
+export declare function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean>;
+export declare function TLiteral(schema: unknown): schema is TLiteral;
+export declare function TNever(schema: unknown): schema is TNever;
+export declare function TNot(schema: unknown): schema is TNot;
+export declare function TNull(schema: unknown): schema is TNull;
+export declare function TNumber(schema: unknown): schema is TNumber;
+export declare function TObject(schema: unknown): schema is TObject;
+export declare function TPromise(schema: unknown): schema is TPromise;
+export declare function TRecord(schema: unknown): schema is TRecord;
+export declare function TRecursive(schema: unknown): schema is {
+    [Hint]: 'Recursive';
+};
+export declare function TRef(schema: unknown): schema is TRef;
+export declare function TString(schema: unknown): schema is TString;
+export declare function TSymbol(schema: unknown): schema is TSymbol;
+export declare function TTemplateLiteral(schema: unknown): schema is TTemplateLiteral<TTemplateLiteralKind[]>;
+export declare function TThis(schema: unknown): schema is TThis;
+export declare function TTransform(schema: unknown): schema is {
+    [TransformKind]: TransformOptions;
+};
+export declare function TTuple(schema: unknown): schema is TTuple;
+export declare function TUndefined(schema: unknown): schema is TUndefined;
+export declare function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral[]>;
+export declare function TUnion(schema: unknown): schema is TUnion;
+export declare function TUint8Array(schema: unknown): schema is TUint8Array;
+export declare function TUnknown(schema: unknown): schema is TUnknown;
+export declare function TUnsafe(schema: unknown): schema is TUnsafe<unknown>;
+export declare function TVoid(schema: unknown): schema is TVoid;
+export declare function TKind(schema: unknown): schema is Record<PropertyKey, unknown> & {
+    [Kind]: string;
+};
+export declare function TSchema(schema: unknown): schema is TSchema;

package/build/types/type/guard/value.d.ts

@@ -0,0 +1,14 @@
+export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<unknown>;
+export declare function IsArray(value: unknown): value is unknown[];
+export declare function IsBigInt(value: unknown): value is bigint;
+export declare function IsBoolean(value: unknown): value is boolean;
+export declare function IsDate(value: unknown): value is Date;
+export declare function IsFunction(value: unknown): value is Function;
+export declare function IsIterator(value: unknown): value is IterableIterator<unknown>;
+export declare function IsNull(value: unknown): value is null;
+export declare function IsNumber(value: unknown): value is number;
+export declare function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
+export declare function IsString(value: unknown): value is string;
+export declare function IsSymbol(value: unknown): value is symbol;
+export declare function IsUint8Array(value: unknown): value is Uint8Array;
+export declare function IsUndefined(value: unknown): value is undefined;