typebox 0.0.1 → 1.0.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<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Decoded extends unknown> = Direction extends 'Decode' ? Decoded : StaticType<Direction, Context, This, Type>;
+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,59 @@
+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/_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 Readaonly from the given type. */
+export type TReadonlyRemove<Type extends TSchema, Result extends TSchema = Type extends TReadonly<infer Type extends TSchema> ? Type : Type> = Result;
+/** Removes Readaonly from the given type. */
+export declare function ReadonlyRemove<Type extends TSchema>(type: Type): TReadonlyRemove<Type>;
+/** Adds Readonly to the given type. */
+export type TReadonlyAdd<Type extends TSchema = TSchema> = ('readOnly' extends keyof Type ? Type : TReadonly<Type>);
+/** Adds Readonly 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 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 Readaonly from the given type. */
+export function ReadonlyRemove(type) {
+    return Memory.Discard(type, ['readOnly']);
+}
+/** Adds Readonly to the given type. */
+export function ReadonlyAdd(type) {
+    return Memory.Update(type, {}, { 'readOnly': true });
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Applies an Readonly 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> {
+    callback: TRefineCallback<Type>;
+    message: string;
+}
+/** Applies a Refine check to the given type. */
+export declare function Refine<Type extends TSchema>(type: Type, callback: 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, callback, message = 'error') {
+    return RefineAdd(type, { callback, 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,16 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TArrayOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticArray<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result = StaticType<Direction, Context, This, Type>[]> = 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<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result = AsyncIterableIterator<StaticType<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,40 @@
+import { type TSchema } from './schema.mjs';
+type TResult<Value extends unknown = unknown> = TValue<Value> | TIssues;
+interface TValue<Value extends unknown = unknown> {
+    value: Value;
+}
+interface TIssues {
+    issues: object[];
+}
+declare class StandardValidatorV1<Value extends unknown = unknown> {
+    private readonly check;
+    private readonly errors;
+    readonly vendor = "typebox";
+    readonly version = 1;
+    constructor(check: (value: unknown) => boolean, errors: (value: unknown) => object[]);
+    readonly validate: (value: unknown) => TResult<Value>;
+}
+export declare class BaseNotImplemented extends Error {
+    constructor(type: Base, override: string);
+}
+/** Base class for creating extension types. */
+export declare class Base<Value extends unknown = unknown> implements TSchema {
+    readonly '~kind': 'Base';
+    readonly '~standard': StandardValidatorV1<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;
+}
+/** Returns true if the given value is a Base type. */
+export declare function IsBase(value: unknown): value is Base;
+export {};

package/build/type/types/base.mjs

@@ -0,0 +1,78 @@
+// deno-fmt-ignore-file
+import { IsKind } from './schema.mjs';
+function Value(value) {
+    return { value };
+}
+function Issues(issues) {
+    return { issues };
+}
+// ------------------------------------------------------------------------------------
+// StandardValidatorV1
+// ------------------------------------------------------------------------------------
+class StandardValidatorV1 {
+    constructor(check, errors) {
+        this.check = check;
+        this.errors = errors;
+        this.vendor = 'typebox';
+        this.version = 1;
+        this.validate = (value) => {
+            return (this.check(value)) ? Value(value) : Issues(this.errors(value));
+        };
+    }
+}
+// ------------------------------------------------------------------
+// BaseError
+// ------------------------------------------------------------------
+export class BaseNotImplemented extends Error {
+    constructor(type, override) {
+        // @ts-ignore - options supported in deno, node, etc.
+        super(`Base type does not implement '${override}' function`, { cause: type });
+    }
+}
+// ------------------------------------------------------------------
+// Base
+// ------------------------------------------------------------------
+/** Base class for creating extension types. */
+export class Base {
+    constructor() {
+        const validator = new StandardValidatorV1(value => this.Check(value), value => this.Errors(value));
+        const configuration = {
+            writable: false,
+            configurable: false,
+            enumerable: false
+        };
+        Object.defineProperty(this, '~kind', { ...configuration, value: 'Base', });
+        Object.defineProperty(this, '~standard', { ...configuration, value: validator });
+    }
+    /** 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 BaseNotImplemented(this, 'Create');
+    }
+}
+// ------------------------------------------------------------------
+// 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;

package/build/type/types/bigint.mjs

@@ -0,0 +1,21 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Pattern
+// ------------------------------------------------------------------
+export const BigIntPattern = '-?(?:0|[1-9][0-9]*)n';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a BigInt type. */
+export function BigInt(options) {
+    return Memory.Create({ '~kind': 'BigInt' }, { type: 'bigint' }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TBigInt. */
+export function IsBigInt(value) {
+    return IsKind(value, 'BigInt');
+}

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+export type StaticBoolean = boolean;
+/** Represents a Boolean type. */
+export interface TBoolean extends TSchema {
+    '~kind': 'Boolean';
+    type: 'boolean';
+}
+/** Creates a Boolean type. */
+export declare function Boolean(options?: TSchemaOptions): TBoolean;
+/** Returns true if the given value is a TBoolean. */
+export declare function IsBoolean(value: unknown): value is TBoolean;

package/build/type/types/boolean.mjs

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

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

@@ -0,0 +1,16 @@
+import { type TSchema } from './schema.mjs';
+import { type TCallInstantiate } from '../engine/call/instantiate.mjs';
+/** Represents a deferred generic Call */
+export interface TCall<Target extends TSchema = TSchema, Arguments extends TSchema[] = TSchema[]> extends TSchema {
+    '~kind': 'Call';
+    target: Target;
+    arguments: Arguments;
+}
+export type TCallConstruct<Target extends TSchema, Arguments extends TSchema[], Result extends TSchema = TCall<Target, Arguments>> = Result;
+export declare function CallConstruct<Target extends TSchema, Arguments extends TSchema[]>(target: Target, arguments_: [...Arguments]): TCallConstruct<Target, Arguments>;
+/** Creates a Call type. */
+export declare function Call<Target extends TSchema, Arguments extends TSchema[]>(target: Target, arguments_: [...Arguments]): TCallInstantiate<{}, {
+    callstack: [];
+}, Target, Arguments>;
+/** Returns true if the given type is a TCall. */
+export declare function IsCall(value: unknown): value is TCall;