@depup/typebox 1.1.6-depup.0

package/build/type/script/token/string.d.mts

@@ -0,0 +1,11 @@
+import { type TTake } from './internal/take.mjs';
+import { type TTrim } from './internal/trim.mjs';
+import { type TSpan } from './span.mjs';
+type TTakeInitial<Quotes extends string[], Input extends string> = (TTake<Quotes, Input>);
+type TTakeSpan<Quote extends string, Input extends string> = (TSpan<Quote, Quote, false, Input>);
+type TTakeString<Quotes extends string[], Input extends string> = (TTakeInitial<Quotes, Input> extends [infer Initial extends string, infer InitialRest extends string] ? TTakeSpan<Initial, `${Initial}${InitialRest}`> : []);
+/** Matches a literal String with the given quotes */
+export type TString<Quotes extends string[], Input extends string> = (TTakeString<Quotes, TTrim<Input>>);
+/** Matches a literal String with the given quotes */
+export declare function String<Quotes extends string[], Input extends string>(quotes: [...Quotes], input: Input): TString<Quotes, Input>;
+export {};

package/build/type/script/token/string.mjs

@@ -0,0 +1,24 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsResult } from './internal/result.mjs';
+import { Take } from './internal/take.mjs';
+import { Trim } from './internal/trim.mjs';
+import { Span } from './span.mjs';
+function TakeInitial(quotes, input) {
+    return Take(quotes, input);
+}
+function TakeSpan(quote, input) {
+    return Span(quote, quote, false, input);
+}
+function TakeString(quotes, input) {
+    const initial = TakeInitial(quotes, input);
+    return (IsResult(initial)
+        ? TakeSpan(initial[0], `${initial[0]}${initial[1]}`)
+        : [] // fail: did not match Initial
+    );
+}
+/** Matches a literal String with the given quotes */
+export function String(quotes, input) {
+    return TakeString(quotes, Trim(input));
+}
+// deno-coverage-ignore-stop

package/build/type/script/token/until.d.mts

@@ -0,0 +1,6 @@
+type TIsEnd<End extends string[], Input extends string> = (End extends [infer Left extends string, ...infer Right extends string[]] ? Input extends `${Left}${string}` ? true : TIsEnd<Right, Input> : false);
+/** Match Input until but not including End. No match if End not found. */
+export type TUntil<End extends string[], Input extends string, Result extends string = ''> = (Input extends `` ? [] : TIsEnd<End, Input> extends true ? [Result, Input] : Input extends `${infer Left extends string}${infer Right extends string}` ? TUntil<End, Right, `${Result}${Left}`> : []);
+/** Match Input until but not including End. No match if End not found. */
+export declare function Until<End extends string[], Input extends string>(end: [...End], input: Input, result?: string): TUntil<End, Input>;
+export {};

package/build/type/script/token/until.mjs

@@ -0,0 +1,21 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsEqual, IsString } from './internal/guard.mjs';
+function IsEnd(end, input) {
+    const [left, ...right] = end;
+    return (IsString(left)
+        ? input.startsWith(left)
+            ? true
+            : IsEnd(right, input)
+        : false);
+}
+/** Match Input until but not including End. No match if End not found. */
+export function Until(end, input, result = '') {
+    return (IsEqual(input, '')
+        ? [] // fail: Input is empty
+        : IsEnd(end, input) ? [result, input] : (() => {
+            const [left, right] = [input.slice(0, 1), input.slice(1)];
+            return Until(end, right, `${result}${left}`);
+        })());
+}
+// deno-coverage-ignore-stop

package/build/type/script/token/until_1.d.mts

@@ -0,0 +1,5 @@
+import { type TUntil } from './until.mjs';
+/** Match Input until but not including End. No match if End not found or match is zero-length. */
+export type TUntil_1<End extends string[], Input extends string> = (TUntil<End, Input> extends [infer Until extends string, infer UntilRest extends string] ? Until extends '' ? [] : [Until, UntilRest] : []);
+/** Match Input until but not including End. No match if End not found or match is zero-length. */
+export declare function Until_1<End extends string[], Input extends string>(end: [...End], input: Input): TUntil_1<End, Input>;

package/build/type/script/token/until_1.mjs

@@ -0,0 +1,16 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsEqual } from './internal/guard.mjs';
+import { IsResult } from './internal/result.mjs';
+import { Until } from './until.mjs';
+/** Match Input until but not including End. No match if End not found or match is zero-length. */
+export function Until_1(end, input) {
+    const until = Until(end, input);
+    return (IsResult(until)
+        ? IsEqual(until[0], '')
+            ? [] // fail: match has no characters
+            : until
+        : [] // fail: did not match Until
+    );
+}
+// deno-coverage-ignore-stop

package/build/type/types/_codec.d.mts

@@ -0,0 +1,30 @@
+import { type StaticDirection, type StaticType } from './static.mjs';
+import { type TSchema } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticCodec<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Decoded extends unknown> = (Direction extends 'Decode' ? Decoded : StaticType<Stack, Direction, Context, This, Omit<Type, '~codec'>>);
+export type TDecodeCallback<Type extends TSchema, Decoded = unknown> = (input: StaticType<[], 'Decode', {}, {}, Type>) => Decoded;
+export type TEncodeCallback<Type extends TSchema, Decoded = unknown> = (input: Decoded) => StaticType<[], 'Decode', {}, {}, Type>;
+export type TCodec<Type extends TSchema = TSchema, Decoded extends unknown = unknown> = Type & {
+    '~codec': {
+        encode: TDecodeCallback<Type, Decoded>;
+        decode: TEncodeCallback<Type, Decoded>;
+    };
+};
+export declare class EncodeBuilder<Type extends TSchema, Decoded extends unknown> {
+    private readonly type;
+    private readonly decode;
+    constructor(type: Type, decode: Function);
+    Encode<Callback extends TEncodeCallback<Type, Decoded>>(callback: Callback): TCodec<Type, Decoded>;
+}
+export declare class DecodeBuilder<Type extends TSchema> {
+    private readonly type;
+    constructor(type: Type);
+    Decode<Callback extends TDecodeCallback<Type>>(callback: Callback): EncodeBuilder<Type, ReturnType<Callback>>;
+}
+/** Creates a bi-directional Codec. Codec functions are called on Value.Decode and Value.Encode. */
+export declare function Codec<Type extends TSchema>(type: Type): DecodeBuilder<Type>;
+/** Createsa  uni-directional Codec with Decode only. The Decode function is called on Value.Decode */
+export declare function Decode<Type extends TSchema, Callback extends TDecodeCallback<Type>>(type: Type, callback: Callback): TCodec<Type, ReturnType<Callback>>;
+/** Creates a uni-directional Codec with Encode only. The Encode function is called on Value.Encode */
+export declare function Encode<Type extends TSchema, Callback extends TEncodeCallback<Type, unknown>>(type: Type, callback: Callback): TCodec<Type, unknown>;
+export declare function IsCodec(value: unknown): value is TCodec;

package/build/type/types/_codec.mjs

@@ -0,0 +1,60 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+export class EncodeBuilder {
+    constructor(type, decode) {
+        this.type = type;
+        this.decode = decode;
+    }
+    Encode(callback) {
+        const type = this.type;
+        const decode = IsCodec(type) ? (value) => this.decode(type['~codec'].decode(value)) : this.decode;
+        const encode = IsCodec(type) ? (value) => type['~codec'].encode(callback(value)) : callback;
+        const codec = { decode, encode };
+        return Memory.Update(this.type, { '~codec': codec }, {});
+    }
+}
+export class DecodeBuilder {
+    constructor(type) {
+        this.type = type;
+    }
+    Decode(callback) {
+        return new EncodeBuilder(this.type, callback);
+    }
+}
+// ------------------------------------------------------------------
+// Bidirectional
+// ------------------------------------------------------------------
+/** Creates a bi-directional Codec. Codec functions are called on Value.Decode and Value.Encode. */
+export function Codec(type) {
+    return new DecodeBuilder(type);
+}
+// ------------------------------------------------------------------
+// Unidirectional
+// ------------------------------------------------------------------
+/** Createsa  uni-directional Codec with Decode only. The Decode function is called on Value.Decode */
+export function Decode(type, callback) {
+    return Codec(type).Decode(callback).Encode(() => {
+        throw Error('Encode not implemented');
+    });
+}
+/** Creates a uni-directional Codec with Encode only. The Encode function is called on Value.Encode */
+export function Encode(type, callback) {
+    return Codec(type).Decode(() => {
+        throw Error('Decode not implemented');
+    }).Encode(callback);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+export function IsCodec(value) {
+    return IsSchema(value) &&
+        Guard.HasPropertyKey(value, '~codec') &&
+        Guard.IsObject(value['~codec']) &&
+        Guard.HasPropertyKey(value['~codec'], 'encode') &&
+        Guard.HasPropertyKey(value['~codec'], 'decode');
+}

package/build/type/types/_immutable.d.mts

@@ -0,0 +1,16 @@
+import { type TSchema } from './schema.mjs';
+/** Removes Immutable from the given type. */
+export type TImmutableRemove<Type extends TSchema, Result extends TSchema = Type extends TImmutable<infer Type extends TSchema> ? Type : Type> = Result;
+/** Removes Immutable from the given type. */
+export declare function ImmutableRemove<Type extends TSchema>(type: Type): TImmutableRemove<Type>;
+/** Adds Immutable to the given type. */
+export type TImmutableAdd<Type extends TSchema = TSchema> = ('~immutable' extends keyof Type ? Type : TImmutable<Type>);
+/** Adds Immutable to the given type. */
+export declare function ImmutableAdd<Type extends TSchema>(type: Type): TImmutableAdd<Type>;
+export type TImmutable<Type extends TSchema = TSchema> = (Type & {
+    '~immutable': true;
+});
+/** Applies an Immutable modifier to the given type. */
+export declare function Immutable<Type extends TSchema>(type: Type): TImmutableAdd<Type>;
+/** Returns true if the given value is a TImmutable */
+export declare function IsImmutable(value: unknown): value is TImmutable<TSchema>;

package/build/type/types/_immutable.mjs

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+/** Removes Immutable from the given type. */
+export function ImmutableRemove(type) {
+    return Memory.Discard(type, ['~immutable']);
+}
+/** Adds Immutable to the given type. */
+export function ImmutableAdd(type) {
+    return Memory.Update(type, { '~immutable': true }, {});
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Applies an Immutable modifier to the given type. */
+export function Immutable(type) {
+    return ImmutableAdd(type);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TImmutable */
+export function IsImmutable(value) {
+    return IsSchema(value) && Guard.HasPropertyKey(value, '~immutable');
+}

package/build/type/types/_optional.d.mts

@@ -0,0 +1,16 @@
+import { type TSchema } from './schema.mjs';
+/** Removes Optional from the given type. */
+export type TOptionalRemove<Type extends TSchema, Result extends TSchema = Type extends TOptional<infer Type extends TSchema> ? Type : Type> = Result;
+/** Removes Optional from the given type. */
+export declare function OptionalRemove<Type extends TSchema>(type: Type): TOptionalRemove<Type>;
+/** Adds Optional to the given type. */
+export type TOptionalAdd<Type extends TSchema = TSchema, Result extends TSchema = '~optional' extends keyof Type ? Type : TOptional<Type>> = Result;
+/** Adds Optional to the given type. */
+export declare function OptionalAdd<Type extends TSchema>(type: Type): TOptionalAdd<Type>;
+export type TOptional<Type extends TSchema = TSchema> = (Type & {
+    '~optional': true;
+});
+/** Applies an Optional modifier to the given type. */
+export declare function Optional<Type extends TSchema>(type: Type): TOptionalAdd<Type>;
+/** Returns true if the given value is TOptional */
+export declare function IsOptional(value: unknown): value is TOptional<TSchema>;

package/build/type/types/_optional.mjs

@@ -0,0 +1,27 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { IsSchema } from './schema.mjs';
+/** Removes Optional from the given type. */
+export function OptionalRemove(type) {
+    const result = Memory.Discard(type, ['~optional']);
+    return result;
+}
+/** Adds Optional to the given type. */
+export function OptionalAdd(type) {
+    return Memory.Update(type, { '~optional': true }, {});
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Applies an Optional modifier to the given type. */
+export function Optional(type) {
+    return OptionalAdd(type);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TOptional */
+export function IsOptional(value) {
+    return IsSchema(value) && Guard.HasPropertyKey(value, '~optional');
+}

package/build/type/types/_readonly.d.mts

@@ -0,0 +1,16 @@
+import { type TSchema } from './schema.mjs';
+/** Removes a Readonly property modifier from the given type. */
+export type TReadonlyRemove<Type extends TSchema, Result extends TSchema = Type extends TReadonly<infer Type extends TSchema> ? Type : Type> = Result;
+/** Removes a Readonly property modifier from the given type. */
+export declare function ReadonlyRemove<Type extends TSchema>(type: Type): TReadonlyRemove<Type>;
+/** Adds a Readonly property modifier to the given type. */
+export type TReadonlyAdd<Type extends TSchema = TSchema> = ('~readonly' extends keyof Type ? Type : TReadonly<Type>);
+/** Adds a Readonly property modifier to the given type. */
+export declare function ReadonlyAdd<Type extends TSchema>(type: Type): TReadonlyAdd<Type>;
+export type TReadonly<Type extends TSchema = TSchema> = (Type & {
+    '~readonly': true;
+});
+/** Applies an Readonly property modifier to the given type. */
+export declare function Readonly<Type extends TSchema>(type: Type): TReadonlyAdd<Type>;
+/** Returns true if the given value is a TReadonly */
+export declare function IsReadonly(value: unknown): value is TReadonly<TSchema>;

package/build/type/types/_readonly.mjs

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+/** Removes a Readonly property modifier from the given type. */
+export function ReadonlyRemove(type) {
+    return Memory.Discard(type, ['~readonly']);
+}
+/** Adds a Readonly property modifier to the given type. */
+export function ReadonlyAdd(type) {
+    return Memory.Update(type, { '~readonly': true }, {});
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Applies an Readonly property modifier to the given type. */
+export function Readonly(type) {
+    return ReadonlyAdd(type);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TReadonly */
+export function IsReadonly(value) {
+    return IsSchema(value) && Guard.HasPropertyKey(value, '~readonly');
+}

package/build/type/types/_refine.d.mts

@@ -0,0 +1,19 @@
+import { type TSchema } from './schema.mjs';
+import { type Static } from './static.mjs';
+/** Applies a Refine check to the given type. */
+export type TRefineAdd<Type extends TSchema = TSchema> = ('~refine' extends keyof Type ? Type : TRefine<Type>);
+/** Applies a Refine check to the given type. */
+export declare function RefineAdd<Type extends TSchema>(type: Type, refinement: TRefinement<Type>): TRefineAdd<Type>;
+/** Represents a type with embedded Refine check. */
+export type TRefine<Type extends TSchema = TSchema> = (Type & {
+    '~refine': TRefinement<Type>[];
+});
+export type TRefineCallback<Type extends TSchema> = (value: Static<Type>) => boolean;
+export interface TRefinement<Type extends TSchema = TSchema> {
+    refine: TRefineCallback<Type>;
+    message: string;
+}
+/** Applies a Refine check to the given type. */
+export declare function Refine<Type extends TSchema>(type: Type, refine: TRefineCallback<Type>, message?: string): TRefineAdd<Type>;
+/** Returns true if the given value is a TRefine. */
+export declare function IsRefine(value: unknown): value is TRefine<TSchema>;

package/build/type/types/_refine.mjs

@@ -0,0 +1,20 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+/** Applies a Refine check to the given type. */
+export function RefineAdd(type, refinement) {
+    const refinements = IsRefine(type) ? [...type['~refine'], refinement] : [refinement];
+    return Memory.Update(type, { '~refine': refinements }, {});
+}
+/** Applies a Refine check to the given type. */
+export function Refine(type, refine, message = 'error') {
+    return RefineAdd(type, { refine, message });
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TRefine. */
+export function IsRefine(value) {
+    return IsSchema(value) && Guard.HasPropertyKey(value, '~refine');
+}

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

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+export type StaticAny = any;
+/** Represents a Any type. */
+export interface TAny extends TSchema {
+    '~kind': 'Any';
+}
+/** Creates a Any type. */
+export declare function Any(options?: TSchemaOptions): TAny;
+/** Returns true if the given value is a TAny. */
+export declare function IsAny(value: unknown): value is TAny;

package/build/type/types/any.mjs

@@ -0,0 +1,18 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file 
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Any type. */
+export function Any(options) {
+    return Memory.Create({ ['~kind']: 'Any' }, {}, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TAny. */
+export function IsAny(value) {
+    return IsKind(value, 'Any');
+}

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

@@ -0,0 +1,17 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TArrayOptions } from './schema.mjs';
+import { type TImmutable } from './_immutable.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticArray<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Array extends TSchema, Item extends TSchema, Result extends readonly unknown[] = Array extends TImmutable ? readonly StaticType<Stack, Direction, Context, This, Item>[] : StaticType<Stack, Direction, Context, This, Item>[]> = Result;
+/** Represents an Array type. */
+export interface TArray<Type extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Array';
+    type: 'array';
+    items: Type;
+}
+/** Creates an Array type. */
+export declare function Array<Type extends TSchema>(items: Type, options?: TArrayOptions): TArray<Type>;
+/** Returns true if the given value is a TArray. */
+export declare function IsArray(value: unknown): value is TArray;
+/** Extracts options from a TArray. */
+export declare function ArrayOptions(type: TArray): TArrayOptions;

package/build/type/types/array.mjs

@@ -0,0 +1,24 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates an Array type. */
+export function Array(items, options) {
+    return Memory.Create({ '~kind': 'Array' }, { type: 'array', items }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TArray. */
+export function IsArray(value) {
+    return IsKind(value, 'Array');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TArray. */
+export function ArrayOptions(type) {
+    return Memory.Discard(type, ['~kind', 'type', 'items']);
+}

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

@@ -0,0 +1,16 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticAsyncIterator<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result = AsyncIterableIterator<StaticType<Stack, Direction, Context, This, Type>>> = Result;
+/** Represents a AsyncIterator. */
+export interface TAsyncIterator<Type extends TSchema = TSchema> extends TSchema {
+    '~kind': 'AsyncIterator';
+    type: 'asyncIterator';
+    iteratorItems: Type;
+}
+/** Creates a AsyncIterator type. */
+export declare function AsyncIterator<Type extends TSchema>(iteratorItems: Type, options?: TSchemaOptions): TAsyncIterator<Type>;
+/** Returns true if the given value is a TAsyncIterator */
+export declare function IsAsyncIterator(value: unknown): value is TAsyncIterator;
+/** Extracts options from a TAsyncIterator. */
+export declare function AsyncIteratorOptions(type: TAsyncIterator): TSchemaOptions;

package/build/type/types/async-iterator.mjs

@@ -0,0 +1,24 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a AsyncIterator type. */
+export function AsyncIterator(iteratorItems, options) {
+    return Memory.Create({ '~kind': 'AsyncIterator' }, { type: 'asyncIterator', iteratorItems }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TAsyncIterator */
+export function IsAsyncIterator(value) {
+    return IsKind(value, 'AsyncIterator');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TAsyncIterator. */
+export function AsyncIteratorOptions(type) {
+    return Memory.Discard(type, ['~kind', 'type', 'iteratorItems']);
+}

package/build/type/types/base.d.mts

@@ -0,0 +1,50 @@
+import { type TSchema } from './schema.mjs';
+import { type XGuard, type XGuardInterface } from '../../schema/types/index.mjs';
+export type StaticBase<Value extends unknown> = Value;
+/**
+ * @deprecated Use Type.Refine() + Type.Unsafe() instead.
+ *
+ *
+ * **Reason:** It is noted that JavaScript class instances do not behave like
+ * plain objects during structural clone or when the TB compositor needs to
+ * assign dynamic modifier properties (such as '~optional').
+ *
+ * Because the TypeBox compositor needs to transform schematics via object clone /
+ * property spread, these operations can result in class instance types losing
+ * methods on the prototype (via clone), which can lead to unexpected structures being
+ * returned. This has led to special-case (non-clone) handling for Base which needs
+ * to be removed as it has proven orthogonal to the TypeBox 1.x design.
+ *
+ * The Base type was introduced in 1.x to try integrate / embed Standard Schema into JSON
+ * Schema; however, support for integrated Standard Schema embedding will not be continued
+ * in TypeBox. This type will be removed in the next minor revision of TypeBox.
+ *
+ * ```typescript
+ * // (Deprecated)
+ * class DateType extends Type.Base<Date> { Check(value) { return value instanceof Date } }
+ *
+ * // (Future)
+ * const DateType = Type.Refine(Type.Unsafe<Date>({}), value => value instanceof Date)
+ * ```
+ */
+export declare class Base<Value extends unknown = unknown> implements TSchema, XGuard<Value> {
+    readonly '~kind': 'Base';
+    readonly '~guard': XGuardInterface<Value>;
+    constructor();
+    /** Checks a value or returns false if invalid */
+    Check(value: unknown): value is Value;
+    /** Returns errors for a value. Return an empty array if valid.  */
+    Errors(value: unknown): object[];
+    /** Converts a value into this type */
+    Convert(value: unknown): unknown;
+    /** Cleans a value according to this type */
+    Clean(value: unknown): unknown;
+    /** Returns a default value for this type */
+    Default(value: unknown): unknown;
+    /** Creates a new instance of this type */
+    Create(): Value;
+    /** Clones this type  */
+    Clone(): Base;
+}
+/** Returns true if the given value is a Base type. */
+export declare function IsBase(value: unknown): value is Base;

package/build/type/types/base.mjs

@@ -0,0 +1,84 @@
+// deno-fmt-ignore-file
+import { Settings } from '../../system/settings/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Type.Base<...>
+// ------------------------------------------------------------------
+function BaseProperty(value) {
+    return {
+        enumerable: Settings.Get().enumerableKind,
+        writable: false,
+        configurable: false,
+        value
+    };
+}
+/**
+ * @deprecated Use Type.Refine() + Type.Unsafe() instead.
+ *
+ *
+ * **Reason:** It is noted that JavaScript class instances do not behave like
+ * plain objects during structural clone or when the TB compositor needs to
+ * assign dynamic modifier properties (such as '~optional').
+ *
+ * Because the TypeBox compositor needs to transform schematics via object clone /
+ * property spread, these operations can result in class instance types losing
+ * methods on the prototype (via clone), which can lead to unexpected structures being
+ * returned. This has led to special-case (non-clone) handling for Base which needs
+ * to be removed as it has proven orthogonal to the TypeBox 1.x design.
+ *
+ * The Base type was introduced in 1.x to try integrate / embed Standard Schema into JSON
+ * Schema; however, support for integrated Standard Schema embedding will not be continued
+ * in TypeBox. This type will be removed in the next minor revision of TypeBox.
+ *
+ * ```typescript
+ * // (Deprecated)
+ * class DateType extends Type.Base<Date> { Check(value) { return value instanceof Date } }
+ *
+ * // (Future)
+ * const DateType = Type.Refine(Type.Unsafe<Date>({}), value => value instanceof Date)
+ * ```
+ */
+export class Base {
+    constructor() {
+        globalThis.Object.defineProperty(this, '~kind', BaseProperty('Base'));
+        globalThis.Object.defineProperty(this, '~guard', BaseProperty({
+            check: (value) => this.Check(value),
+            errors: (value) => this.Errors(value)
+        }));
+    }
+    /** Checks a value or returns false if invalid */
+    Check(value) {
+        return true;
+    }
+    /** Returns errors for a value. Return an empty array if valid.  */
+    Errors(value) {
+        return [];
+    }
+    /** Converts a value into this type */
+    Convert(value) {
+        return value;
+    }
+    /** Cleans a value according to this type */
+    Clean(value) {
+        return value;
+    }
+    /** Returns a default value for this type */
+    Default(value) {
+        return value;
+    }
+    /** Creates a new instance of this type */
+    Create() {
+        throw new Error('Create not implemented');
+    }
+    /** Clones this type  */
+    Clone() {
+        throw Error('Clone not implemented');
+    }
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a Base type. */
+export function IsBase(value) {
+    return IsKind(value, 'Base');
+}

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TNumberOptions } from './schema.mjs';
+export declare const BigIntPattern = "-?(?:0|[1-9][0-9]*)n";
+export type StaticBigInt = bigint;
+/** Represents a BigInt type. */
+export interface TBigInt extends TSchema {
+    '~kind': 'BigInt';
+    type: 'bigint';
+}
+/** Creates a BigInt type. */
+export declare function BigInt(options?: TNumberOptions): TBigInt;
+/** Returns true if the given value is a TBigInt. */
+export declare function IsBigInt(value: unknown): value is TBigInt;