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

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

@@ -0,0 +1,39 @@
+import { JsonTypeBuilder } from './json';
+import { type TAsyncIterator } from '../async-iterator/index';
+import { type TAwaited } from '../awaited/index';
+import { type TBigInt, type BigIntOptions } from '../bigint/index';
+import { type TConstructor } from '../constructor/index';
+import { type TConstructorParameters } from '../constructor-parameters/index';
+import { type TDate, type DateOptions } from '../date/index';
+import { type TFunction } from '../function/index';
+import { type TInstanceType } from '../instance-type/index';
+import { type TIterator } from '../iterator/index';
+import { type TParameters } from '../parameters/index';
+import { type TPromise } from '../promise/index';
+import { type TRegExp } from '../regexp/index';
+import { type TReturnType } from '../return-type/index';
+import { type TSchema, type SchemaOptions } from '../schema/index';
+import { type TSymbol } from '../symbol/index';
+import { type TUint8Array, type Uint8ArrayOptions } from '../uint8array/index';
+import { type TUndefined } from '../undefined/index';
+import { type TVoid } from '../void/index';
+export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
+    AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;
+    Awaited<T extends TSchema>(schema: T, options?: SchemaOptions): TAwaited<T>;
+    BigInt(options?: BigIntOptions): TBigInt;
+    ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
+    Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
+    Date(options?: DateOptions): TDate;
+    Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
+    InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;
+    Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T>;
+    Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T>;
+    Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
+    RegExp(pattern: string, options?: SchemaOptions): TRegExp;
+    RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;
+    ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
+    Symbol(options?: SchemaOptions): TSymbol;
+    Undefined(options?: SchemaOptions): TUndefined;
+    Uint8Array(options?: Uint8ArrayOptions): TUint8Array;
+    Void(options?: SchemaOptions): TVoid;
+}

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

@@ -0,0 +1,90 @@
+import { type TAny } from '../any/index';
+import { type TArray, type ArrayOptions } from '../array/index';
+import { type TBoolean } from '../boolean/index';
+import { type TComposite } from '../composite/index';
+import { type TConst } from '../const/index';
+import { type TDeref } from '../deref/index';
+import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index';
+import { type TExclude } from '../exclude/index';
+import { type TExtends } from '../extends/index';
+import { type TExtract } from '../extract/index';
+import { TIndex, type IndexedKeyResolve } from '../indexed/index';
+import { type IntegerOptions, type TInteger } from '../integer/index';
+import { type IntersectOptions, type IntersectResolve } from '../intersect/index';
+import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index';
+import { type TKeyOf } from '../keyof/index';
+import { type TLiteral, type TLiteralValue } from '../literal/index';
+import { type TNever } from '../never/index';
+import { type TNot } from '../not/index';
+import { type TNull } from '../null/index';
+import { type TNumber, type NumberOptions } from '../number/index';
+import { type TObject, type TProperties, type ObjectOptions } from '../object/index';
+import { type TOmit } from '../omit/index';
+import { type TOptional } from '../optional/index';
+import { type TPartial } from '../partial/index';
+import { type TPick } from '../pick/index';
+import { type TReadonly } from '../readonly/index';
+import { type TReadonlyOptional } from '../readonly-optional/index';
+import { type RecordResolve } from '../record/index';
+import { type TRecursive, type TThis } from '../recursive/index';
+import { type TRef } from '../ref/index';
+import { type TRequired } from '../required/index';
+import { type TRest } from '../rest/index';
+import { type TSchema, type SchemaOptions } from '../schema/index';
+import { type TString, type StringOptions } from '../string/index';
+import { type TTemplateLiteral, type TTemplateLiteralKind, type TemplateLiteralSyntax } from '../template-literal/index';
+import { TransformDecodeBuilder } from '../transform/index';
+import { type TTuple } from '../tuple/index';
+import { type UnionResolve } from '../union/index';
+import { type TUnknown } from '../unknown/index';
+import { type TUnsafe, type UnsafeOptions } from '../unsafe/index';
+export declare class JsonTypeBuilder {
+    Strict<T extends TSchema>(schema: T): T;
+    ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T>;
+    Readonly<T extends TSchema>(schema: T): TReadonly<T>;
+    Optional<T extends TSchema>(schema: T): TOptional<T>;
+    Any(options?: SchemaOptions): TAny;
+    Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;
+    Boolean(options?: SchemaOptions): TBoolean;
+    Capitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TCapitalize<T>;
+    Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T>;
+    Const<T>(value: T, options?: SchemaOptions): TConst<T>;
+    Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
+    Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;
+    Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options?: SchemaOptions): TExtends<L, R, T, U>;
+    Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
+    Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
+    Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
+    Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;
+    Integer(options?: IntegerOptions): TInteger;
+    Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): IntersectResolve<T>;
+    KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
+    Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
+    Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TLowercase<T>;
+    Never(options?: SchemaOptions): TNever;
+    Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T>;
+    Null(options?: SchemaOptions): TNull;
+    Number(options?: NumberOptions): TNumber;
+    Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+    Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
+    Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
+    Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
+    Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+    Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
+    Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordResolve<K, T>;
+    Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
+    Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
+    Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
+    Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
+    Rest<T extends TSchema>(schema: T): TRest<T>;
+    String(options?: StringOptions): TString;
+    TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+    TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
+    Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;
+    Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
+    Uncapitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TUncapitalize<T>;
+    Union<T extends TSchema[]>(schemas: [...T], options?: SchemaOptions): UnionResolve<T>;
+    Unknown(options?: SchemaOptions): TUnknown;
+    Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
+    Uppercase<T extends TSchema>(schema: T, options?: SchemaOptions): TUppercase<T>;
+}

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

@@ -0,0 +1,58 @@
+export { Any } from '../any/index';
+export { Array } from '../array/index';
+export { AsyncIterator } from '../async-iterator/index';
+export { Awaited } from '../awaited/index';
+export { BigInt } from '../bigint/index';
+export { Boolean } from '../boolean/index';
+export { Composite } from '../composite/index';
+export { Const } from '../const/index';
+export { Constructor } from '../constructor/index';
+export { ConstructorParameters } from '../constructor-parameters/index';
+export { Date } from '../date/index';
+export { Deref } from '../deref/index';
+export { Enum } from '../enum/index';
+export { Exclude } from '../exclude/index';
+export { Extends } from '../extends/index';
+export { Extract } from '../extract/index';
+export { Function } from '../function/index';
+export { Index } from '../indexed/index';
+export { InstanceType } from '../instance-type/index';
+export { Integer } from '../integer/index';
+export { Intersect } from '../intersect/index';
+export { Capitalize, Uncapitalize, Lowercase, Uppercase } from '../intrinsic/index';
+export { Iterator } from '../iterator/index';
+export { KeyOf } from '../keyof/index';
+export { Literal } from '../literal/index';
+export { Mapped } from '../mapped/index';
+export { Never } from '../never/index';
+export { Not } from '../not/index';
+export { Null } from '../null/index';
+export { Number } from '../number/index';
+export { Object } from '../object/index';
+export { Omit } from '../omit/index';
+export { Optional } from '../optional/index';
+export { Parameters } from '../parameters/index';
+export { Partial } from '../partial/index';
+export { Pick } from '../pick/index';
+export { Promise } from '../promise/index';
+export { Readonly } from '../readonly/index';
+export { ReadonlyOptional } from '../readonly-optional/index';
+export { Record } from '../record/index';
+export { Recursive } from '../recursive/index';
+export { Ref } from '../ref/index';
+export { RegExp } from '../regexp/index';
+export { Required } from '../required/index';
+export { Rest } from '../rest/index';
+export { ReturnType } from '../return-type/index';
+export { Strict } from '../strict/index';
+export { String } from '../string/index';
+export { Symbol } from '../symbol/index';
+export { TemplateLiteral } from '../template-literal/index';
+export { Transform } from '../transform/index';
+export { Tuple } from '../tuple/index';
+export { Uint8Array } from '../uint8array/index';
+export { Undefined } from '../undefined/index';
+export { Union } from '../union/index';
+export { Unknown } from '../unknown/index';
+export { Unsafe } from '../unsafe/index';
+export { Void } from '../void/index';

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

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

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

@@ -0,0 +1,12 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface Uint8ArrayOptions extends SchemaOptions {
+    maxByteLength?: number;
+    minByteLength?: number;
+}
+export interface TUint8Array extends TSchema, Uint8ArrayOptions {
+    [Kind]: 'Uint8Array';
+    static: Uint8Array;
+    type: 'uint8array';
+}
+export declare function Uint8Array(options?: Uint8ArrayOptions): TUint8Array;

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { type TNever } from '../never/index';
+import { OptionalFromUnion } from '../modifiers/index';
+import { Kind } from '../symbols/index';
+export type UnionResolve<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : OptionalFromUnion<T>);
+export declare function UnionResolve<T extends TSchema[]>(T: [...T]): UnionResolve<T>;
+export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Union';
+    static: {
+        [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : never;
+    }[number];
+    anyOf: T;
+}
+export declare function Union<T extends TSchema[]>(T: [...T], options?: SchemaOptions): UnionResolve<T>;

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface UnsafeOptions extends SchemaOptions {
+    [Kind]?: string;
+}
+export interface TUnsafe<T> extends TSchema {
+    [Kind]: string;
+    static: T;
+}
+export declare function Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;

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

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

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

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

package/build/types/value/cast/cast.d.ts

@@ -0,0 +1,21 @@
+import type { TSchema } from '../../type/schema/index';
+import type { Static } from '../../type/static/index';
+export declare class ValueCastArrayUniqueItemsTypeError extends Error {
+    readonly schema: TSchema;
+    readonly value: unknown;
+    constructor(schema: TSchema, value: unknown);
+}
+export declare class ValueCastNeverTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare class ValueCastRecursiveTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare class ValueCastUnknownTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare function Cast<T extends TSchema>(schema: T, references: TSchema[], value: unknown): Static<T>;
+export declare function Cast<T extends TSchema>(schema: T, value: unknown): Static<T>;

package/build/types/value/cast/index.d.ts

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

package/build/types/value/check/check.d.ts

@@ -0,0 +1,8 @@
+import type { TSchema } from '../../type/schema/index';
+import type { Static } from '../../type/static/index';
+export declare class ValueCheckUnknownTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare function Check<T extends TSchema>(schema: T, references: TSchema[], value: unknown): value is Static<T>;
+export declare function Check<T extends TSchema>(schema: T, value: unknown): value is Static<T>;

package/build/types/value/check/index.d.ts

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

package/build/types/value/clean/clean.d.ts

@@ -0,0 +1,3 @@
+import type { TSchema } from '../../type/schema/index';
+export declare function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Clean<T extends TSchema>(schema: T): unknown;

package/build/types/value/clean/index.d.ts

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

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

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

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

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

package/build/types/value/convert/convert.d.ts

@@ -0,0 +1,7 @@
+import type { TSchema } from '../../type/schema/index';
+export declare class ValueConvertUnknownTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Convert<T extends TSchema>(schema: T, value: unknown): unknown;

package/build/types/value/convert/index.d.ts

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

package/build/types/value/create/create.d.ts

@@ -0,0 +1,29 @@
+import type { TSchema } from '../../type/schema/index';
+import type { Static } from '../../type/static/index';
+export declare class ValueCreateUnknownTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare class ValueCreateNeverTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare class ValueCreateNotTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare class ValueCreateIntersectTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare class ValueCreateTempateLiteralTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+export declare class ValueCreateRecursiveInstantiationError extends Error {
+    readonly schema: TSchema;
+    readonly recursiveMaxDepth: number;
+    constructor(schema: TSchema, recursiveMaxDepth: number);
+}
+export declare function Create<T extends TSchema>(schema: T, references: TSchema[]): Static<T>;
+export declare function Create<T extends TSchema>(schema: T): Static<T>;

package/build/types/value/create/index.d.ts

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

package/build/types/value/default/default.d.ts

@@ -0,0 +1,3 @@
+import type { TSchema } from '../../type/schema/index';
+export declare function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Default<T extends TSchema>(schema: T, value: unknown): unknown;

package/build/types/value/default/index.d.ts

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

package/build/types/value/delta/delta.d.ts

@@ -0,0 +1,41 @@
+import type { Static } from '../../type/static/index';
+export type Insert = Static<typeof Insert>;
+export declare const Insert: import("../../type/object/object").TObject<{
+    type: import("../../type/literal/literal").TLiteral<"insert">;
+    path: import("../../type/string/string").TString;
+    value: import("../../type/unknown/unknown").TUnknown;
+}>;
+export type Update = Static<typeof Update>;
+export declare const Update: import("../../type/object/object").TObject<{
+    type: import("../../type/literal/literal").TLiteral<"update">;
+    path: import("../../type/string/string").TString;
+    value: import("../../type/unknown/unknown").TUnknown;
+}>;
+export type Delete = Static<typeof Delete>;
+export declare const Delete: import("../../type/object/object").TObject<{
+    type: import("../../type/literal/literal").TLiteral<"delete">;
+    path: import("../../type/string/string").TString;
+}>;
+export type Edit = Static<typeof Edit>;
+export declare const Edit: import("../../type/union/union").TUnion<[import("../../type/object/object").TObject<{
+    type: import("../../type/literal/literal").TLiteral<"insert">;
+    path: import("../../type/string/string").TString;
+    value: import("../../type/unknown/unknown").TUnknown;
+}>, import("../../type/object/object").TObject<{
+    type: import("../../type/literal/literal").TLiteral<"update">;
+    path: import("../../type/string/string").TString;
+    value: import("../../type/unknown/unknown").TUnknown;
+}>, import("../../type/object/object").TObject<{
+    type: import("../../type/literal/literal").TLiteral<"delete">;
+    path: import("../../type/string/string").TString;
+}>]>;
+export declare class ValueDeltaObjectWithSymbolKeyError extends Error {
+    readonly key: unknown;
+    constructor(key: unknown);
+}
+export declare class ValueDeltaUnableToDiffUnknownValue extends Error {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export declare function Diff(current: unknown, next: unknown): Edit[];
+export declare function Patch<T = any>(current: unknown, edits: Edit[]): T;

package/build/types/value/delta/index.d.ts

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

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

@@ -0,0 +1,8 @@
+import type { TSchema } from '../../type/schema/index';
+import type { TRef } from '../../type/ref/index';
+import type { TThis } from '../../type/recursive/index';
+export declare class TypeDereferenceError extends Error {
+    readonly schema: TRef | TThis;
+    constructor(schema: TRef | TThis);
+}
+export declare function Deref(schema: TRef | TThis, references: TSchema[]): TSchema;

package/build/types/value/deref/index.d.ts

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

package/build/types/value/equal/equal.d.ts

@@ -0,0 +1 @@
+export declare function Equal<T>(left: T, right: unknown): right is T;

package/build/types/value/equal/index.d.ts

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

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

@@ -0,0 +1,24 @@
+export type ObjectType = Record<PropertyKey, unknown>;
+export type ArrayType = unknown[];
+export type ValueType = null | undefined | symbol | bigint | number | boolean | string;
+export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<any>;
+export declare function IsIterator(value: unknown): value is IterableIterator<any>;
+export declare function IsTypedArray(value: unknown): value is TypedArrayType;
+export declare function IsPromise(value: unknown): value is Promise<unknown>;
+export declare function IsUint8Array(value: unknown): value is Uint8Array;
+export declare function IsDate(value: unknown): value is Date;
+export declare function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is ObjectType & Record<K, unknown>;
+export declare function IsPlainObject(value: unknown): value is ObjectType;
+export declare function IsObject(value: unknown): value is ObjectType;
+export declare function IsArray(value: unknown): value is ArrayType;
+export declare function IsUndefined(value: unknown): value is undefined;
+export declare function IsNull(value: unknown): value is null;
+export declare function IsBoolean(value: unknown): value is boolean;
+export declare function IsNumber(value: unknown): value is number;
+export declare function IsInteger(value: unknown): value is number;
+export declare function IsBigInt(value: unknown): value is bigint;
+export declare function IsString(value: unknown): value is string;
+export declare function IsFunction(value: unknown): value is Function;
+export declare function IsSymbol(value: unknown): value is symbol;
+export declare function IsValueType(value: unknown): value is ValueType;

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

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

package/build/types/value/hash/hash.d.ts

@@ -0,0 +1,5 @@
+export declare class ValueHashError extends Error {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export declare function Hash(value: unknown): bigint;

package/build/types/value/hash/index.d.ts

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

package/build/types/value/index.d.ts

@@ -0,0 +1,18 @@
+export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
+export { Cast, ValueCastArrayUniqueItemsTypeError, ValueCastNeverTypeError, ValueCastRecursiveTypeError, ValueCastUnknownTypeError } from './cast/index';
+export { Check } from './check/index';
+export { Clean } from './clean/index';
+export { Clone } from './clone/index';
+export { Convert, ValueConvertUnknownTypeError } from './convert/index';
+export { Create, ValueCreateIntersectTypeError, ValueCreateNeverTypeError, ValueCreateNotTypeError, ValueCreateRecursiveInstantiationError, ValueCreateTempateLiteralTypeError, ValueCreateUnknownTypeError } from './create/index';
+export { Default } from './default/index';
+export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaObjectWithSymbolKeyError, ValueDeltaUnableToDiffUnknownValue } from './delta/index';
+export { Equal } from './equal/index';
+export { Hash, ValueHashError } from './hash/index';
+export { Mutate, type Mutable, ValueMutateInvalidRootMutationError, ValueMutateTypeMismatchError } from './mutate/index';
+export { ValuePointer } from './pointer/index';
+export { Decode, Encode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index';
+export { ArrayType, HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, ObjectType, TypedArrayType, ValueType, } from './guard/index';
+import { Value } from './value/index';
+export { Value };
+export default Value;

package/build/types/value/mutate/index.d.ts

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

package/build/types/value/mutate/mutate.d.ts

@@ -0,0 +1,10 @@
+export declare class ValueMutateTypeMismatchError extends Error {
+    constructor();
+}
+export declare class ValueMutateInvalidRootMutationError extends Error {
+    constructor();
+}
+export type Mutable = {
+    [key: string]: unknown;
+} | unknown[];
+export declare function Mutate(current: Mutable, next: Mutable): void;

package/build/types/value/pointer/index.d.ts

@@ -0,0 +1 @@
+export * as ValuePointer from './pointer';

package/build/types/value/pointer/pointer.d.ts

@@ -0,0 +1,16 @@
+export declare class ValuePointerRootSetError extends Error {
+    readonly value: unknown;
+    readonly path: string;
+    readonly update: unknown;
+    constructor(value: unknown, path: string, update: unknown);
+}
+export declare class ValuePointerRootDeleteError extends Error {
+    readonly value: unknown;
+    readonly path: string;
+    constructor(value: unknown, path: string);
+}
+export declare function Format(pointer: string): IterableIterator<string>;
+export declare function Set(value: any, pointer: string, update: unknown): void;
+export declare function Delete(value: any, pointer: string): void;
+export declare function Has(value: any, pointer: string): boolean;
+export declare function Get(value: any, pointer: string): any;

package/build/types/value/transform/decode.d.ts

@@ -0,0 +1,14 @@
+import { ValueError } from '../../errors/index';
+import type { TSchema } from '../../type/schema/index';
+export declare class TransformDecodeCheckError extends Error {
+    readonly schema: TSchema;
+    readonly value: unknown;
+    readonly error: ValueError;
+    constructor(schema: TSchema, value: unknown, error: ValueError);
+}
+export declare class TransformDecodeError extends Error {
+    readonly schema: TSchema;
+    readonly value: unknown;
+    constructor(schema: TSchema, value: unknown, error: any);
+}
+export declare function Decode(schema: TSchema, references: TSchema[], value: unknown): unknown;

package/build/types/value/transform/encode.d.ts

@@ -0,0 +1,14 @@
+import { ValueError } from '../../errors/index';
+import type { TSchema } from '../../type/schema/index';
+export declare class TransformEncodeCheckError extends Error {
+    readonly schema: TSchema;
+    readonly value: unknown;
+    readonly error: ValueError;
+    constructor(schema: TSchema, value: unknown, error: ValueError);
+}
+export declare class TransformEncodeError extends Error {
+    readonly schema: TSchema;
+    readonly value: unknown;
+    constructor(schema: TSchema, value: unknown, error: any);
+}
+export declare function Encode(schema: TSchema, references: TSchema[], value: unknown): unknown;

package/build/types/value/transform/has.d.ts

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

package/build/types/value/transform/index.d.ts

@@ -0,0 +1,3 @@
+export * from './decode';
+export * from './encode';
+export * from './has';

package/build/types/value/value/index.d.ts

@@ -0,0 +1 @@
+export * as Value from './value';