@depup/sinclair__typebox 0.34.48-depup.0

package/build/esm/type/type/json.mjs

@@ -0,0 +1,221 @@
+import { Any } from '../any/index.mjs';
+import { Array } from '../array/index.mjs';
+import { Boolean } from '../boolean/index.mjs';
+import { Composite } from '../composite/index.mjs';
+import { Const } from '../const/index.mjs';
+import { Enum } from '../enum/index.mjs';
+import { Exclude } from '../exclude/index.mjs';
+import { Extends } from '../extends/index.mjs';
+import { Extract } from '../extract/index.mjs';
+import { Index } from '../indexed/index.mjs';
+import { Integer } from '../integer/index.mjs';
+import { Intersect } from '../intersect/index.mjs';
+import { Capitalize, Uncapitalize, Lowercase, Uppercase } from '../intrinsic/index.mjs';
+import { KeyOf } from '../keyof/index.mjs';
+import { Literal } from '../literal/index.mjs';
+import { Mapped } from '../mapped/index.mjs';
+import { Never } from '../never/index.mjs';
+import { Not } from '../not/index.mjs';
+import { Null } from '../null/index.mjs';
+import { Module } from '../module/index.mjs';
+import { Number } from '../number/index.mjs';
+import { Object } from '../object/index.mjs';
+import { Omit } from '../omit/index.mjs';
+import { Optional } from '../optional/index.mjs';
+import { Partial } from '../partial/index.mjs';
+import { Pick } from '../pick/index.mjs';
+import { Readonly } from '../readonly/index.mjs';
+import { ReadonlyOptional } from '../readonly-optional/index.mjs';
+import { Record } from '../record/index.mjs';
+import { Recursive } from '../recursive/index.mjs';
+import { Ref } from '../ref/index.mjs';
+import { Required } from '../required/index.mjs';
+import { Rest } from '../rest/index.mjs';
+import { String } from '../string/index.mjs';
+import { TemplateLiteral } from '../template-literal/index.mjs';
+import { Transform } from '../transform/index.mjs';
+import { Tuple } from '../tuple/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Unknown } from '../unknown/index.mjs';
+import { Unsafe } from '../unsafe/index.mjs';
+/** Json Type Builder with Static Resolution for TypeScript */
+export class JsonTypeBuilder {
+    // ------------------------------------------------------------------------
+    // Modifiers
+    // ------------------------------------------------------------------------
+    /** `[Json]` Creates a Readonly and Optional property */
+    ReadonlyOptional(type) {
+        return ReadonlyOptional(type);
+    }
+    /** `[Json]` Creates a Readonly property */
+    Readonly(type, enable) {
+        return Readonly(type, enable ?? true);
+    }
+    /** `[Json]` Creates a Optional property */
+    Optional(type, enable) {
+        return Optional(type, enable ?? true);
+    }
+    // ------------------------------------------------------------------------
+    // Types
+    // ------------------------------------------------------------------------
+    /** `[Json]` Creates an Any type */
+    Any(options) {
+        return Any(options);
+    }
+    /** `[Json]` Creates an Array type */
+    Array(items, options) {
+        return Array(items, options);
+    }
+    /** `[Json]` Creates a Boolean type */
+    Boolean(options) {
+        return Boolean(options);
+    }
+    /** `[Json]` Intrinsic function to Capitalize LiteralString types */
+    Capitalize(schema, options) {
+        return Capitalize(schema, options);
+    }
+    /** `[Json]` Creates a Composite object type */
+    Composite(schemas, options) {
+        return Composite(schemas, options); // (error) TS 5.4.0-dev - review TComposite implementation
+    }
+    /** `[JavaScript]` Creates a readonly const type from the given value. */
+    Const(value, options) {
+        return Const(value, options);
+    }
+    /** `[Json]` Creates a Enum type */
+    Enum(item, options) {
+        return Enum(item, options);
+    }
+    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+    Exclude(unionType, excludedMembers, options) {
+        return Exclude(unionType, excludedMembers, options);
+    }
+    /** `[Json]` Creates a Conditional type */
+    Extends(L, R, T, F, options) {
+        return Extends(L, R, T, F, options);
+    }
+    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+    Extract(type, union, options) {
+        return Extract(type, union, options);
+    }
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index(type, key, options) {
+        return Index(type, key, options);
+    }
+    /** `[Json]` Creates an Integer type */
+    Integer(options) {
+        return Integer(options);
+    }
+    /** `[Json]` Creates an Intersect type */
+    Intersect(types, options) {
+        return Intersect(types, options);
+    }
+    /** `[Json]` Creates a KeyOf type */
+    KeyOf(type, options) {
+        return KeyOf(type, options);
+    }
+    /** `[Json]` Creates a Literal type */
+    Literal(literalValue, options) {
+        return Literal(literalValue, options);
+    }
+    /** `[Json]` Intrinsic function to Lowercase LiteralString types */
+    Lowercase(type, options) {
+        return Lowercase(type, options);
+    }
+    /** `[Json]` Creates a Mapped object type */
+    Mapped(key, map, options) {
+        return Mapped(key, map, options);
+    }
+    /** `[Json]` Creates a Type Definition Module. */
+    Module(properties) {
+        return Module(properties);
+    }
+    /** `[Json]` Creates a Never type */
+    Never(options) {
+        return Never(options);
+    }
+    /** `[Json]` Creates a Not type */
+    Not(type, options) {
+        return Not(type, options);
+    }
+    /** `[Json]` Creates a Null type */
+    Null(options) {
+        return Null(options);
+    }
+    /** `[Json]` Creates a Number type */
+    Number(options) {
+        return Number(options);
+    }
+    /** `[Json]` Creates an Object type */
+    Object(properties, options) {
+        return Object(properties, options);
+    }
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
+    Omit(schema, selector, options) {
+        return Omit(schema, selector, options);
+    }
+    /** `[Json]` Constructs a type where all properties are optional */
+    Partial(type, options) {
+        return Partial(type, options);
+    }
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
+    Pick(type, key, options) {
+        return Pick(type, key, options);
+    }
+    /** `[Json]` Creates a Record type */
+    Record(key, value, options) {
+        return Record(key, value, options);
+    }
+    /** `[Json]` Creates a Recursive type */
+    Recursive(callback, options) {
+        return Recursive(callback, options);
+    }
+    /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+    Ref(...args) {
+        return Ref(args[0], args[1]);
+    }
+    /** `[Json]` Constructs a type where all properties are required */
+    Required(type, options) {
+        return Required(type, options);
+    }
+    /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
+    Rest(type) {
+        return Rest(type);
+    }
+    /** `[Json]` Creates a String type */
+    String(options) {
+        return String(options);
+    }
+    /** `[Json]` Creates a TemplateLiteral type */
+    TemplateLiteral(unresolved, options) {
+        return TemplateLiteral(unresolved, options);
+    }
+    /** `[Json]` Creates a Transform type */
+    Transform(type) {
+        return Transform(type);
+    }
+    /** `[Json]` Creates a Tuple type */
+    Tuple(types, options) {
+        return Tuple(types, options);
+    }
+    /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
+    Uncapitalize(type, options) {
+        return Uncapitalize(type, options);
+    }
+    /** `[Json]` Creates a Union type */
+    Union(types, options) {
+        return Union(types, options);
+    }
+    /** `[Json]` Creates an Unknown type */
+    Unknown(options) {
+        return Unknown(options);
+    }
+    /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
+    Unsafe(options) {
+        return Unsafe(options);
+    }
+    /** `[Json]` Intrinsic function to Uppercase LiteralString types */
+    Uppercase(schema, options) {
+        return Uppercase(schema, options);
+    }
+}

package/build/esm/type/type/type.d.mts

@@ -0,0 +1,59 @@
+export { Any } from '../any/index.mjs';
+export { Argument } from '../argument/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 { 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 { Instantiate } from '../instantiate/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 { Module } from '../module/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 { 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/esm/type/type/type.mjs

@@ -0,0 +1,62 @@
+// ------------------------------------------------------------------
+// Type: Module
+// ------------------------------------------------------------------
+export { Any } from '../any/index.mjs';
+export { Argument } from '../argument/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 { 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 { Instantiate } from '../instantiate/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 { Module } from '../module/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 { 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/esm/type/uint8array/index.d.mts

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

package/build/esm/type/uint8array/index.mjs

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

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

@@ -0,0 +1,13 @@
+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';
+}
+/** `[JavaScript]` Creates a Uint8Array type */
+export declare function Uint8Array(options?: Uint8ArrayOptions): TUint8Array;

package/build/esm/type/uint8array/uint8array.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a Uint8Array type */
+export function Uint8Array(options) {
+    return CreateType({ [Kind]: 'Uint8Array', type: 'Uint8Array' }, options);
+}

package/build/esm/type/undefined/index.d.mts

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

package/build/esm/type/undefined/index.mjs

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

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

@@ -0,0 +1,9 @@
+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';
+}
+/** `[JavaScript]` Creates a Undefined type */
+export declare function Undefined(options?: SchemaOptions): TUndefined;

package/build/esm/type/undefined/undefined.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a Undefined type */
+export function Undefined(options) {
+    return CreateType({ [Kind]: 'Undefined', type: 'undefined' }, options);
+}

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

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

package/build/esm/type/union/index.mjs

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

package/build/esm/type/union/union-create.d.mts

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

package/build/esm/type/union/union-create.mjs

@@ -0,0 +1,5 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+export function UnionCreate(T, options) {
+    return CreateType({ [Kind]: 'Union', anyOf: T }, options);
+}

package/build/esm/type/union/union-evaluated.d.mts

@@ -0,0 +1,13 @@
+import type { SchemaOptions, TSchema } from '../schema/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TOptional } from '../optional/index.mjs';
+import type { TReadonly } from '../readonly/index.mjs';
+import type { TUnion } from './union-type.mjs';
+type TIsUnionOptional<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<TSchema> ? true : TIsUnionOptional<Right> : false);
+type TRemoveOptionalFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromRest<Right, [...Result, TRemoveOptionalFromType<S>]> : TRemoveOptionalFromRest<Right, [...Result, Left]> : Result);
+type TRemoveOptionalFromType<Type extends TSchema> = (Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TRemoveOptionalFromType<Type>> : Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromType<Type> : Type);
+type TResolveUnion<Types extends TSchema[], Result extends TSchema[] = TRemoveOptionalFromRest<Types>, IsOptional extends boolean = TIsUnionOptional<Types>> = (IsOptional extends true ? TOptional<TUnion<Result>> : TUnion<Result>);
+export type TUnionEvaluated<Types extends TSchema[]> = (Types extends [TSchema] ? Types[0] : Types extends [] ? TNever : TResolveUnion<Types>);
+/** `[Json]` Creates an evaluated Union type */
+export declare function UnionEvaluated<Types extends TSchema[], Result = TUnionEvaluated<Types>>(T: [...Types], options?: SchemaOptions): Result;
+export {};

package/build/esm/type/union/union-evaluated.mjs

@@ -0,0 +1,36 @@
+import { CreateType } from '../create/type.mjs';
+import { OptionalKind } from '../symbols/index.mjs';
+import { Discard } from '../discard/index.mjs';
+import { Never } from '../never/index.mjs';
+import { Optional } from '../optional/index.mjs';
+import { UnionCreate } from './union-create.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsOptional } from '../guard/kind.mjs';
+// prettier-ignore
+function IsUnionOptional(types) {
+    return types.some(type => IsOptional(type));
+}
+// prettier-ignore
+function RemoveOptionalFromRest(types) {
+    return types.map(left => IsOptional(left) ? RemoveOptionalFromType(left) : left);
+}
+// prettier-ignore
+function RemoveOptionalFromType(T) {
+    return (Discard(T, [OptionalKind]));
+}
+// prettier-ignore
+function ResolveUnion(types, options) {
+    const isOptional = IsUnionOptional(types);
+    return (isOptional
+        ? Optional(UnionCreate(RemoveOptionalFromRest(types), options))
+        : UnionCreate(RemoveOptionalFromRest(types), options));
+}
+/** `[Json]` Creates an evaluated Union type */
+export function UnionEvaluated(T, options) {
+    // prettier-ignore
+    return (T.length === 1 ? CreateType(T[0], options) :
+        T.length === 0 ? Never(options) :
+            ResolveUnion(T, options));
+}

package/build/esm/type/union/union-type.d.mts

@@ -0,0 +1,12 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+type UnionStatic<T extends TSchema[], P extends unknown[]> = {
+    [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
+}[number];
+export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Union';
+    static: UnionStatic<T, this['params']>;
+    anyOf: T;
+}
+export {};

package/build/esm/type/union/union-type.mjs

@@ -0,0 +1 @@
+import { Kind } from '../symbols/index.mjs';

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

@@ -0,0 +1,6 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import type { TUnion } from './union-type.mjs';
+export type Union<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TUnion<T>);
+/** `[Json]` Creates a Union type */
+export declare function Union<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): Union<Types>;

package/build/esm/type/union/union.mjs

@@ -0,0 +1,10 @@
+import { Never } from '../never/index.mjs';
+import { CreateType } from '../create/type.mjs';
+import { UnionCreate } from './union-create.mjs';
+/** `[Json]` Creates a Union type */
+export function Union(types, options) {
+    // prettier-ignore
+    return (types.length === 0 ? Never(options) :
+        types.length === 1 ? CreateType(types[0], options) :
+            UnionCreate(types, options));
+}

package/build/esm/type/unknown/index.d.mts

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

package/build/esm/type/unknown/index.mjs

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

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

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

package/build/esm/type/unknown/unknown.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates an Unknown type */
+export function Unknown(options) {
+    return CreateType({ [Kind]: 'Unknown' }, options);
+}

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

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

package/build/esm/type/unsafe/index.mjs

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

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

@@ -0,0 +1,11 @@
+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;
+}
+/** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
+export declare function Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;

package/build/esm/type/unsafe/unsafe.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
+export function Unsafe(options = {}) {
+    return CreateType({ [Kind]: options[Kind] ?? 'Unsafe' }, options);
+}

package/build/esm/type/void/index.d.mts

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

package/build/esm/type/void/index.mjs

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

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

@@ -0,0 +1,9 @@
+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';
+}
+/** `[JavaScript]` Creates a Void type */
+export declare function Void(options?: SchemaOptions): TVoid;

package/build/esm/type/void/void.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a Void type */
+export function Void(options) {
+    return CreateType({ [Kind]: 'Void', type: 'void' }, options);
+}

package/build/esm/value/assert/assert.d.mts

@@ -0,0 +1,15 @@
+import { ValueErrorIterator, ValueError } from '../../errors/index.mjs';
+import { TypeBoxError } from '../../type/error/error.mjs';
+import { TSchema } from '../../type/schema/index.mjs';
+import { Static } from '../../type/static/index.mjs';
+export declare class AssertError extends TypeBoxError {
+    #private;
+    error: ValueError | undefined;
+    constructor(iterator: ValueErrorIterator);
+    /** Returns an iterator for each error in this value. */
+    Errors(): ValueErrorIterator;
+}
+/** Asserts a value matches the given type or throws an `AssertError` if invalid */
+export declare function Assert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): asserts value is Static<T>;
+/** Asserts a value matches the given type or throws an `AssertError` if invalid */
+export declare function Assert<T extends TSchema>(schema: T, value: unknown): asserts value is Static<T>;