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

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

@@ -0,0 +1,14 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export type TupleResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TupleResolve<R, P>] : [];
+export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Tuple';
+    static: TupleResolve<T, this['params']>;
+    type: 'array';
+    items?: T;
+    additionalItems?: false;
+    minItems: number;
+    maxItems: number;
+}
+export declare function Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;

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

@@ -0,0 +1,5 @@
+export { JsonTypeBuilder } from './json.mjs';
+import { JavaScriptTypeBuilder } from './javascript.mjs';
+declare const Type: JavaScriptTypeBuilder;
+export { JavaScriptTypeBuilder };
+export { Type };

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

@@ -0,0 +1,39 @@
+import { JsonTypeBuilder } from './json.mjs';
+import { type TAsyncIterator } from '../async-iterator/index.mjs';
+import { type TAwaited } from '../awaited/index.mjs';
+import { type TBigInt, type BigIntOptions } from '../bigint/index.mjs';
+import { type TConstructor } from '../constructor/index.mjs';
+import { type TConstructorParameters } from '../constructor-parameters/index.mjs';
+import { type TDate, type DateOptions } from '../date/index.mjs';
+import { type TFunction } from '../function/index.mjs';
+import { type TInstanceType } from '../instance-type/index.mjs';
+import { type TIterator } from '../iterator/index.mjs';
+import { type TParameters } from '../parameters/index.mjs';
+import { type TPromise } from '../promise/index.mjs';
+import { type TRegExp } from '../regexp/index.mjs';
+import { type TReturnType } from '../return-type/index.mjs';
+import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
+import { type TSymbol } from '../symbol/index.mjs';
+import { type TUint8Array, type Uint8ArrayOptions } from '../uint8array/index.mjs';
+import { type TUndefined } from '../undefined/index.mjs';
+import { type TVoid } from '../void/index.mjs';
+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/import/type/type/json.d.mts

@@ -0,0 +1,90 @@
+import { type TAny } from '../any/index.mjs';
+import { type TArray, type ArrayOptions } from '../array/index.mjs';
+import { type TBoolean } from '../boolean/index.mjs';
+import { type TComposite } from '../composite/index.mjs';
+import { type TConst } from '../const/index.mjs';
+import { type TDeref } from '../deref/index.mjs';
+import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index.mjs';
+import { type TExclude } from '../exclude/index.mjs';
+import { type TExtends } from '../extends/index.mjs';
+import { type TExtract } from '../extract/index.mjs';
+import { TIndex, type IndexedKeyResolve } from '../indexed/index.mjs';
+import { type IntegerOptions, type TInteger } from '../integer/index.mjs';
+import { type IntersectOptions, type IntersectResolve } from '../intersect/index.mjs';
+import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index.mjs';
+import { type TKeyOf } from '../keyof/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TNot } from '../not/index.mjs';
+import { type TNull } from '../null/index.mjs';
+import { type TNumber, type NumberOptions } from '../number/index.mjs';
+import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
+import { type TOmit } from '../omit/index.mjs';
+import { type TOptional } from '../optional/index.mjs';
+import { type TPartial } from '../partial/index.mjs';
+import { type TPick } from '../pick/index.mjs';
+import { type TReadonly } from '../readonly/index.mjs';
+import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
+import { type RecordResolve } from '../record/index.mjs';
+import { type TRecursive, type TThis } from '../recursive/index.mjs';
+import { type TRef } from '../ref/index.mjs';
+import { type TRequired } from '../required/index.mjs';
+import { type TRest } from '../rest/index.mjs';
+import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
+import { type TString, type StringOptions } from '../string/index.mjs';
+import { type TTemplateLiteral, type TTemplateLiteralKind, type TemplateLiteralSyntax } from '../template-literal/index.mjs';
+import { TransformDecodeBuilder } from '../transform/index.mjs';
+import { type TTuple } from '../tuple/index.mjs';
+import { type UnionResolve } from '../union/index.mjs';
+import { type TUnknown } from '../unknown/index.mjs';
+import { type TUnsafe, type UnsafeOptions } from '../unsafe/index.mjs';
+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/import/type/type/type.d.mts

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

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

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

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

@@ -0,0 +1,12 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+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/import/type/undefined/index.d.mts

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { OptionalFromUnion } from '../modifiers/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+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/import/type/unknown/index.d.mts

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+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/import/type/void/index.d.mts

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

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

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

package/build/import/value/cast/cast.d.mts

@@ -0,0 +1,21 @@
+import type { TSchema } from '../../type/schema/index.mjs';
+import type { Static } from '../../type/static/index.mjs';
+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/import/value/cast/index.d.mts

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

package/build/import/value/check/check.d.mts

@@ -0,0 +1,8 @@
+import type { TSchema } from '../../type/schema/index.mjs';
+import type { Static } from '../../type/static/index.mjs';
+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/import/value/check/index.d.mts

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

package/build/import/value/clean/clean.d.mts

@@ -0,0 +1,3 @@
+import type { TSchema } from '../../type/schema/index.mjs';
+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/import/value/clean/index.d.mts

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

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

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

package/build/import/value/convert/convert.d.mts

@@ -0,0 +1,7 @@
+import type { TSchema } from '../../type/schema/index.mjs';
+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/import/value/convert/index.d.mts

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

package/build/import/value/create/create.d.mts

@@ -0,0 +1,29 @@
+import type { TSchema } from '../../type/schema/index.mjs';
+import type { Static } from '../../type/static/index.mjs';
+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/import/value/create/index.d.mts

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

package/build/import/value/default/default.d.mts

@@ -0,0 +1,3 @@
+import type { TSchema } from '../../type/schema/index.mjs';
+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/import/value/default/index.d.mts

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

package/build/import/value/delta/delta.d.mts

@@ -0,0 +1,41 @@
+import type { Static } from '../../type/static/index.mjs';
+export type Insert = Static<typeof Insert>;
+export declare const Insert: import("../../type/object/object.mjs").TObject<{
+    type: import("../../type/literal/literal.mjs").TLiteral<"insert">;
+    path: import("../../type/string/string.mjs").TString;
+    value: import("../../type/unknown/unknown.mjs").TUnknown;
+}>;
+export type Update = Static<typeof Update>;
+export declare const Update: import("../../type/object/object.mjs").TObject<{
+    type: import("../../type/literal/literal.mjs").TLiteral<"update">;
+    path: import("../../type/string/string.mjs").TString;
+    value: import("../../type/unknown/unknown.mjs").TUnknown;
+}>;
+export type Delete = Static<typeof Delete>;
+export declare const Delete: import("../../type/object/object.mjs").TObject<{
+    type: import("../../type/literal/literal.mjs").TLiteral<"delete">;
+    path: import("../../type/string/string.mjs").TString;
+}>;
+export type Edit = Static<typeof Edit>;
+export declare const Edit: import("../../type/union/union.mjs").TUnion<[import("../../type/object/object.mjs").TObject<{
+    type: import("../../type/literal/literal.mjs").TLiteral<"insert">;
+    path: import("../../type/string/string.mjs").TString;
+    value: import("../../type/unknown/unknown.mjs").TUnknown;
+}>, import("../../type/object/object.mjs").TObject<{
+    type: import("../../type/literal/literal.mjs").TLiteral<"update">;
+    path: import("../../type/string/string.mjs").TString;
+    value: import("../../type/unknown/unknown.mjs").TUnknown;
+}>, import("../../type/object/object.mjs").TObject<{
+    type: import("../../type/literal/literal.mjs").TLiteral<"delete">;
+    path: import("../../type/string/string.mjs").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/import/value/delta/index.d.mts

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

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

@@ -0,0 +1,8 @@
+import type { TSchema } from '../../type/schema/index.mjs';
+import type { TRef } from '../../type/ref/index.mjs';
+import type { TThis } from '../../type/recursive/index.mjs';
+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/import/value/deref/index.d.mts

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

package/build/import/value/equal/index.d.mts

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

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

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

package/build/import/value/hash/index.d.mts

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

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

@@ -0,0 +1,16 @@
+export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
+export { Cast, ValueCastArrayUniqueItemsTypeError, ValueCastNeverTypeError, ValueCastRecursiveTypeError, ValueCastUnknownTypeError } from './cast/index.mjs';
+export { Check } from './check/index.mjs';
+export { Clean } from './clean/index.mjs';
+export { Clone } from './clone/index.mjs';
+export { Convert, ValueConvertUnknownTypeError } from './convert/index.mjs';
+export { Create, ValueCreateIntersectTypeError, ValueCreateNeverTypeError, ValueCreateNotTypeError, ValueCreateRecursiveInstantiationError, ValueCreateTempateLiteralTypeError, ValueCreateUnknownTypeError } from './create/index.mjs';
+export { Default } from './default/index.mjs';
+export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaObjectWithSymbolKeyError, ValueDeltaUnableToDiffUnknownValue } from './delta/index.mjs';
+export { Equal } from './equal/index.mjs';
+export { Hash, ValueHashError } from './hash/index.mjs';
+export { Mutate, type Mutable, ValueMutateInvalidRootMutationError, ValueMutateTypeMismatchError } from './mutate/index.mjs';
+export { ValuePointer } from './pointer/index.mjs';
+export { Decode, Encode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
+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.mjs';
+export { Value } from './value/index.mjs';

package/build/import/value/mutate/index.d.mts

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

package/build/import/value/pointer/index.d.mts

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

package/build/import/value/transform/decode.d.mts

@@ -0,0 +1,14 @@
+import { ValueError } from '../../errors/index.mjs';
+import type { TSchema } from '../../type/schema/index.mjs';
+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/import/value/transform/encode.d.mts

@@ -0,0 +1,14 @@
+import { ValueError } from '../../errors/index.mjs';
+import type { TSchema } from '../../type/schema/index.mjs';
+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/import/value/transform/has.d.mts

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

package/build/import/value/transform/index.d.mts

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

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

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

package/build/import/value/value/value.d.mts

@@ -0,0 +1,29 @@
+import { type Mutable } from '../mutate/index.mjs';
+import { Edit } from '../delta/index.mjs';
+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 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>;
+export declare function Create<T extends TSchema>(schema: T, references: TSchema[]): Static<T>;
+export declare function Create<T extends TSchema>(schema: T): Static<T>;
+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>;
+export declare function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+export declare function Clean<T extends TSchema>(schema: T, value: unknown): unknown;
+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;
+export declare function Clone<T>(value: T): T;
+export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
+export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
+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;
+export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R;
+export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value: unknown): R;
+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;
+export declare function Equal<T>(left: T, right: unknown): right is T;
+export declare function Diff(current: unknown, next: unknown): Edit[];
+export declare function Hash(value: unknown): bigint;
+export declare function Patch<T = any>(current: unknown, edits: Edit[]): T;
+export declare function Mutate(current: Mutable, next: Mutable): void;

package/build/require/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/require/type/clone/value.d.ts

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

package/build/require/type/discard/discard.d.ts

@@ -0,0 +1 @@
+export declare function Discard(value: Record<PropertyKey, any>, keys: PropertyKey[]): Record<PropertyKey, any>;

package/build/require/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;