typebox 0.0.1 → 1.0.0-rc

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

@@ -0,0 +1,199 @@
+export interface TSchema {
+}
+export declare function IsKind<Kind extends string>(value: unknown, kind: Kind): value is {
+    ['~kind']: Kind;
+};
+export declare function IsSchema(value: unknown): value is TSchema;
+export interface TSchemaOptions {
+    /**
+     * Allows for additional, unlisted properties to be included, typically for extensibility.
+     */
+    [key: PropertyKey]: unknown;
+    /**
+     * Specifies the URI of a JSON Schema that the current schema adheres to.
+     */
+    $schema?: string;
+    /**
+     * A URI that serves as a unique identifier for the schema.
+     */
+    $id?: string;
+    /**
+     * A short explanation about the purpose of the data described by the schema.
+     */
+    title?: string;
+    /**
+     * A detailed explanation of the data described by the schema.
+     */
+    description?: string;
+    /**
+     * A default value for the data, used when no value is provided.
+     */
+    default?: unknown;
+    /**
+     * Provides one or more examples of valid data conforming to the schema.
+     */
+    examples?: unknown;
+    /**
+     * Indicates that the data should only be readable and not modified.
+     */
+    readOnly?: boolean;
+    /**
+     * Indicates that the data should only be writable and not read back.
+     */
+    writeOnly?: boolean;
+    /**
+     * A schema to apply conditionally: if the data validates against this schema, 'then' applies.
+     */
+    if?: TSchema;
+    /**
+     * A schema to apply if the data validates against the 'if' schema.
+     */
+    then?: TSchema;
+    /**
+     * A schema to apply if the data does not validate against the 'if' schema.
+     */
+    else?: TSchema;
+}
+export interface TObjectOptions extends TSchemaOptions {
+    /**
+     * Defines whether additional properties are allowed beyond those explicitly defined in `properties`.
+     */
+    additionalProperties?: TSchema | boolean;
+    /**
+     * The minimum number of properties required in the object.
+     */
+    minProperties?: number;
+    /**
+     * The maximum number of properties allowed in the object.
+     */
+    maxProperties?: number;
+    /**
+     * Defines conditional requirements for properties.
+     */
+    dependencies?: Record<string, boolean | TSchema | string[]>;
+    /**
+     * Specifies properties that *must* be present if a given property is present.
+     */
+    dependentRequired?: Record<string, string[]>;
+    /**
+     * Defines schemas that apply if a specific property is present.
+     */
+    dependentSchemas?: Record<string, TSchema>;
+    /**
+     * Maps regular expressions to schemas properties matching a pattern must validate against the schema.
+     */
+    patternProperties?: Record<string, TSchema>;
+    /**
+     * A schema that all property names within the object must validate against.
+     */
+    propertyNames?: TSchema;
+}
+export interface TArrayOptions extends TSchemaOptions {
+    /**
+     * The minimum number of items allowed in the array.
+     */
+    minItems?: number;
+    /**
+     * The maximum number of items allowed in the array.
+     */
+    maxItems?: number;
+    /**
+     * A schema that at least one item in the array must validate against.
+     */
+    contains?: TSchema;
+    /**
+     * The minimum number of array items that must validate against the `contains` schema.
+     */
+    minContains?: number;
+    /**
+     * The maximum number of array items that may validate against the `contains` schema.
+     */
+    maxContains?: number;
+    /**
+     * An array of schemas, where each schema in `prefixItems` validates against items at corresponding positions from the beginning of the array.
+     */
+    prefixItems?: TSchema[];
+    /**
+     * If `true`, all items in the array must be unique.
+     */
+    uniqueItems?: boolean;
+}
+export interface TTupleOptions extends TArrayOptions {
+    /**
+     * A schema to apply to any items in the array that were not validated by `prefixItems` or `items`. If `false`, no additional items are allowed.
+     */
+    unevaluatedItems?: TSchema | boolean;
+}
+export interface TIntersectOptions extends TSchemaOptions {
+    /**
+     * A schema to apply to any properties in the object that were not validated by other keywords like `properties`, `patternProperties`, or `additionalProperties`. If `false`, no additional properties are allowed.
+     */
+    unevaluatedProperties?: TSchema | boolean;
+}
+export interface TNumberOptions extends TSchemaOptions {
+    /**
+     * Specifies an exclusive upper limit for the number (number must be less than this value).
+     */
+    exclusiveMaximum?: number | bigint;
+    /**
+     * Specifies an exclusive lower limit for the number (number must be greater than this value).
+     */
+    exclusiveMinimum?: number | bigint;
+    /**
+     * Specifies an inclusive upper limit for the number (number must be less than or equal to this value).
+     */
+    maximum?: number | bigint;
+    /**
+     * Specifies an inclusive lower limit for the number (number must be greater than or equal to this value).
+     */
+    minimum?: number | bigint;
+    /**
+     * Specifies that the number must be a multiple of this value.
+     */
+    multipleOf?: number;
+}
+export type TFormat = 'base64' | 'date-time' | 'date' | 'duration' | 'email' | 'hostname' | 'idn-email' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'iri-reference' | 'iri' | 'json-pointer-uri-fragment' | 'json-pointer' | 'json-string' | 'regex' | 'relative-json-pointer' | 'time' | 'uri-reference' | 'uri-template' | 'url' | 'uuid' | ({} & string);
+export interface TStringOptions extends TSchemaOptions {
+    /**
+     * Specifies the expected string format.
+     *
+     * Common values include:
+     * - `base64` – Base64-encoded string.
+     * - `date-time` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time format.
+     * - `date` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date (YYYY-MM-DD).
+     * - `duration` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) duration format.
+     * - `email` – RFC 5321/5322 compliant email address.
+     * - `hostname` – RFC 1034/1035 compliant host name.
+     * - `idn-email` – Internationalized email address.
+     * - `idn-hostname` – Internationalized host name.
+     * - `ipv4` – IPv4 address.
+     * - `ipv6` – IPv6 address.
+     * - `iri` / `iri-reference` – Internationalized Resource Identifier.
+     * - `json-pointer` / `json-pointer-uri-fragment` – JSON Pointer format.
+     * - `json-string` – String containing valid JSON.
+     * - `regex` – Regular expression syntax.
+     * - `relative-json-pointer` – Relative JSON Pointer format.
+     * - `time` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) time (HH:MM:SS).
+     * - `uri-reference` / `uri-template` – URI reference or template.
+     * - `url` – Web URL format.
+     * - `uuid` – RFC 4122 UUID string.
+     *
+     * May also be a custom format string.
+     */
+    format?: TFormat;
+    /**
+     * Specifies the minimum number of characters allowed in the string.
+     * Must be a non-negative integer.
+     */
+    minLength?: number;
+    /**
+     * Specifies the maximum number of characters allowed in the string.
+     * Must be a non-negative integer.
+     */
+    maxLength?: number;
+    /**
+     * Specifies a regular expression pattern that the string value must match.
+     * Can be provided as a string (ECMA-262 regex syntax) or a `RegExp` object.
+     */
+    pattern?: string | RegExp;
+}

package/build/type/types/schema.mjs

@@ -0,0 +1,15 @@
+// deno-lint-ignore-file
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Kind
+// ------------------------------------------------------------------
+export function IsKind(value, kind) {
+    return Guard.IsObject(value) && Guard.HasPropertyKey(value, '~kind') && Guard.IsEqual(value["~kind"], kind);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+export function IsSchema(value) {
+    return Guard.IsObject(value);
+}

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

@@ -0,0 +1,47 @@
+import type { StaticCodec, TCodec } from './_codec.mjs';
+import type { StaticAny, TAny } from './any.mjs';
+import type { StaticArray, TArray } from './array.mjs';
+import type { StaticAsyncIterator, TAsyncIterator } from './async-iterator.mjs';
+import type { StaticBigInt, TBigInt } from './bigint.mjs';
+import type { StaticBoolean, TBoolean } from './boolean.mjs';
+import type { StaticConstructor, TConstructor } from './constructor.mjs';
+import type { StaticCyclic, TCyclic } from './cyclic.mjs';
+import type { StaticEnum, TEnum, TEnumValue } from './enum.mjs';
+import type { StaticFunction, TFunction } from './function.mjs';
+import type { StaticInteger, TInteger } from './integer.mjs';
+import type { StaticIntersect, TIntersect } from './intersect.mjs';
+import type { StaticIterator, TIterator } from './iterator.mjs';
+import type { StaticLiteral, TLiteral, TLiteralValue } from './literal.mjs';
+import type { StaticNever, TNever } from './never.mjs';
+import type { StaticNull, TNull } from './null.mjs';
+import type { StaticNumber, TNumber } from './number.mjs';
+import type { StaticObject, TObject } from './object.mjs';
+import type { StaticPromise, TPromise } from './promise.mjs';
+import type { TProperties } from './properties.mjs';
+import type { StaticRecord, TRecord } from './record.mjs';
+import type { StaticRef, TRef } from './ref.mjs';
+import type { TSchema } from './schema.mjs';
+import type { StaticString, TString } from './string.mjs';
+import type { StaticSymbol, TSymbol } from './symbol.mjs';
+import type { StaticTemplateLiteral, TTemplateLiteral } from './template-literal.mjs';
+import type { StaticThis, TThis } from './this.mjs';
+import type { StaticTuple, TTuple } from './tuple.mjs';
+import type { StaticUndefined, TUndefined } from './undefined.mjs';
+import type { StaticUnion, TUnion } from './union.mjs';
+import type { StaticUnknown, TUnknown } from './unknown.mjs';
+import type { StaticUnsafe, TUnsafe } from './unsafe.mjs';
+import type { StaticVoid, TVoid } from './void.mjs';
+import type { XStatic } from '../../schema/types/static.mjs';
+export type StaticEvaluate<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type StaticDirection = 'Encode' | 'Decode';
+export type StaticType<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema> = (Type extends TCodec<infer Type extends TSchema, infer Decoded extends unknown> ? StaticCodec<Direction, Context, This, Type, Decoded> : Type extends TAny ? StaticAny : Type extends TArray<infer Type extends TSchema> ? StaticArray<Direction, Context, This, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? StaticAsyncIterator<Direction, Context, This, Type> : Type extends TBigInt ? StaticBigInt : Type extends TBoolean ? StaticBoolean : Type extends TConstructor<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? StaticConstructor<Direction, Context, This, Parameters, ReturnType> : Type extends TEnum<infer Values extends TEnumValue[]> ? StaticEnum<Values> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? StaticFunction<Direction, Context, This, Parameters, ReturnType> : Type extends TInteger ? StaticInteger : Type extends TIntersect<infer Types extends TSchema[]> ? StaticIntersect<Direction, Context, This, Types> : Type extends TIterator<infer Types extends TSchema> ? StaticIterator<Direction, Context, This, Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? StaticLiteral<Value> : Type extends TNever ? StaticNever : Type extends TNull ? StaticNull : Type extends TNumber ? StaticNumber : Type extends TObject<infer Properties extends TProperties> ? StaticObject<Direction, Context, This, Properties> : Type extends TPromise<infer Type extends TSchema> ? StaticPromise<Direction, Context, This, Type> : Type extends TRecord<infer Key extends string, infer Value extends TSchema> ? StaticRecord<Direction, Context, This, Key, Value> : Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? StaticCyclic<Direction, Context, This, Defs, Ref> : Type extends TRef<infer Ref extends string> ? StaticRef<Direction, Context, This, Ref> : Type extends TString ? StaticString : Type extends TSymbol ? StaticSymbol : Type extends TTemplateLiteral<infer Pattern extends string> ? StaticTemplateLiteral<Pattern> : Type extends TThis ? StaticThis<Direction, Context, This> : Type extends TTuple<infer Types extends TSchema[]> ? StaticTuple<Direction, Context, This, Types> : Type extends TUndefined ? StaticUndefined : Type extends TUnion<infer Types extends TSchema[]> ? StaticUnion<Direction, Context, This, Types> : Type extends TUnknown ? StaticUnknown : Type extends TUnsafe<infer Type extends unknown> ? StaticUnsafe<Type> : Type extends TVoid ? StaticVoid : XStatic<Type>);
+/** Infers a static type from a TypeBox type using Parse logic. */
+export type StaticParse<Type extends TSchema, Context extends TProperties = {}> = StaticType<'Decode', Context, {}, Type>;
+/** Infers a static type from a TypeBox type using Decode logic. */
+export type StaticDecode<Type extends TSchema, Context extends TProperties = {}> = StaticType<'Decode', Context, {}, Type>;
+/** Infers a static type from a TypeBox type using Encode logic. */
+export type StaticEncode<Type extends TSchema, Context extends TProperties = {}> = StaticType<'Encode', Context, {}, Type>;
+/** Infers a static type from a TypeBox type. */
+export type Static<Type extends TSchema, Context extends TProperties = {}> = StaticType<'Encode', Context, {}, Type>;

package/build/type/types/static.mjs

@@ -0,0 +1,3 @@
+// deno-lint-ignore-file
+// deno-fmt-ignore-file
+export {};

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TStringOptions } from './schema.mjs';
+export declare const StringPattern = ".*";
+export type StaticString = string;
+/** Represents a String type. */
+export interface TString extends TSchema {
+    '~kind': 'String';
+    type: 'string';
+}
+/** Creates a String type. */
+export declare function String(options?: TStringOptions): TString;
+/** Returns true if the given value is TString. */
+export declare function IsString(value: unknown): value is TString;

package/build/type/types/string.mjs

@@ -0,0 +1,22 @@
+// deno-lint-ignore-file
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// StringPattern
+// ------------------------------------------------------------------
+export const StringPattern = '.*';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a String type. */
+export function String(options) {
+    return Memory.Create({ '~kind': 'String' }, { type: 'string' }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TString. */
+export function IsString(value) {
+    return IsKind(value, 'String');
+}

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

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

package/build/type/types/symbol.mjs

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

package/build/type/types/template-literal.d.mts

@@ -0,0 +1,24 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TDeferred } from './deferred.mjs';
+import { type TParseTemplateIntoTypes } from '../engine/patterns/template.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+import { type TTemplateLiteralStatic } from '../engine/template-literal/static.mjs';
+export type StaticTemplateLiteral<Pattern extends string> = (TTemplateLiteralStatic<Pattern>);
+/** Represents a TemplateLiteral type. */
+export interface TTemplateLiteral<Pattern extends string = string> extends TSchema {
+    '~kind': 'TemplateLiteral';
+    type: 'string';
+    pattern: Pattern;
+}
+/** Creates a deferred TemplateLiteral action. */
+export type TTemplateLiteralDeferred<Types extends TSchema[]> = (TDeferred<'TemplateLiteral', [Types]>);
+/** Creates a deferred TemplateLiteral action. */
+export declare function TemplateLiteralDeferred<Types extends TSchema[]>(types: [...Types], options?: TSchemaOptions): TTemplateLiteralDeferred<Types>;
+export type TTemplateLiteralConstruct<Types extends TSchema[]> = (TInstantiate<{}, TTemplateLiteralDeferred<Types>>);
+export declare function TemplateLiteralConstruct<Types extends TSchema[]>(types: [...Types], options?: TSchemaOptions): TTemplateLiteralConstruct<Types>;
+/** Creates a TemplateLiteral type. */
+export declare function TemplateLiteral<Template extends string>(template: Template, options?: TSchemaOptions): TTemplateLiteralConstruct<TParseTemplateIntoTypes<Template>>;
+/** Creates a TemplateLiteral type. */
+export declare function TemplateLiteral<Types extends TSchema[]>(types: [...Types], options?: TSchemaOptions): TTemplateLiteralConstruct<Types>;
+/** Returns true if the given value is TTemplateLiteral. */
+export declare function IsTemplateLiteral(value: unknown): value is TTemplateLiteral;

package/build/type/types/template-literal.mjs

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsKind } from './schema.mjs';
+import { Deferred } from './deferred.mjs';
+import { ParseTemplateIntoTypes } from '../engine/patterns/template.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred TemplateLiteral action. */
+export function TemplateLiteralDeferred(types, options = {}) {
+    return Deferred('TemplateLiteral', [types], options);
+}
+export function TemplateLiteralConstruct(types, options = {}) {
+    return Instantiate({}, TemplateLiteralDeferred(types, options));
+}
+/** Creates a TemplateLiteral type. */
+export function TemplateLiteral(input, options = {}) {
+    const types = Guard.IsString(input) ? ParseTemplateIntoTypes(input) : input;
+    return TemplateLiteralConstruct(types, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TTemplateLiteral. */
+export function IsTemplateLiteral(value) {
+    return IsKind(value, 'TemplateLiteral');
+}

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

@@ -0,0 +1,14 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TObject } from './object.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticThis<Direction extends StaticDirection, Context extends TProperties, This extends TProperties> = (StaticType<Direction, Context, This, TObject<This>>);
+/** Represents a This type. */
+export interface TThis extends TSchema {
+    '~kind': 'This';
+    $ref: '#';
+}
+/** Creates a This type. */
+export declare function This(options?: TSchemaOptions): TThis;
+/** Returns true if the given value is TThis. */
+export declare function IsThis(value: unknown): value is TThis;

package/build/type/types/this.mjs

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

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

@@ -0,0 +1,37 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TTupleOptions } from './schema.mjs';
+import { type TArray } from './array.mjs';
+import { type TOptional } from './_optional.mjs';
+import { type TProperties } from './properties.mjs';
+import { type TReadonly } from './_readonly.mjs';
+import { type TRest } from './rest.mjs';
+type StaticLast<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result extends unknown[]> = (Type extends TRest<infer RestType extends TSchema> ? RestType extends TArray<infer ArrayType extends TSchema> ? [...Result, ...TStaticElement<Direction, Context, This, ArrayType>[0][]] : [...Result, never] : [...Result, ...TStaticElement<Direction, Context, This, Type>]);
+type TStaticElement<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, IsReadonly extends boolean = Type extends TReadonly ? true : false, IsOptional extends boolean = Type extends TOptional ? true : false, Inferred extends unknown = StaticType<Direction, Context, This, Type>, Result extends [unknown?] = ([
+    IsReadonly,
+    IsOptional
+] extends [true, true] ? [Readonly<Inferred>?] : [
+    IsReadonly,
+    IsOptional
+] extends [false, true] ? [Inferred?] : [
+    IsReadonly,
+    IsOptional
+] extends [true, false] ? [Readonly<Inferred>] : [
+    Inferred
+])> = Result;
+export type TStaticElements<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Types extends TSchema[], Result extends unknown[] = []> = (Types extends [infer Last extends TSchema] ? StaticLast<Direction, Context, This, Last, Result> : Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TStaticElements<Direction, Context, This, Right, [...Result, ...TStaticElement<Direction, Context, This, Left>]> : Result);
+export type StaticTuple<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Types extends TSchema[], Elements extends unknown[] = TStaticElements<Direction, Context, This, Types>, Result extends unknown[] = Elements> = Result;
+/** Represents a Tuple type. */
+export interface TTuple<Types extends TSchema[] = TSchema[]> extends TSchema {
+    '~kind': 'Tuple';
+    type: 'array';
+    additionalItems: false;
+    items: Types;
+    minItems: Types['length'];
+}
+/** Creates a Tuple type. */
+export declare function Tuple<Types extends TSchema[]>(types: [...Types], options?: TTupleOptions): TTuple<Types>;
+/** Returns true if the given value is TTuple. */
+export declare function IsTuple(value: unknown): value is TTuple;
+/** Extracts options from a TTuple. */
+export declare function TupleOptions(type: TTuple): TTupleOptions;
+export {};

package/build/type/types/tuple.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Tuple type. */
+export function Tuple(types, options = {}) {
+    const [items, minItems, additionalItems] = [types, types.length, false];
+    return Memory.Create({ ['~kind']: 'Tuple' }, { type: 'array', additionalItems, items, minItems }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TTuple. */
+export function IsTuple(value) {
+    return IsKind(value, 'Tuple');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TTuple. */
+export function TupleOptions(type) {
+    return Memory.Discard(type, ['~kind', 'type', 'items', 'minItems', 'additionalItems']);
+}

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

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

package/build/type/types/undefined.mjs

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

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

@@ -0,0 +1,15 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticUnion<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Types extends TSchema[], Result extends unknown = never> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? StaticUnion<Direction, Context, This, Right, Result | StaticType<Direction, Context, This, Left>> : Result);
+/** Represents a logical Union type. */
+export interface TUnion<Types extends TSchema[] = TSchema[]> extends TSchema {
+    '~kind': 'Union';
+    anyOf: Types;
+}
+/** Creates a Union type. */
+export declare function Union<Types extends TSchema[]>(anyOf: [...Types], options?: TSchemaOptions): TUnion<Types>;
+/** Returns true if the given value is TUnion. */
+export declare function IsUnion(value: unknown): value is TUnion;
+/** Extracts options from a TUnion. */
+export declare function UnionOptions(type: TUnion): TSchemaOptions;

package/build/type/types/union.mjs

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

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

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

package/build/type/types/unknown.mjs

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

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

@@ -0,0 +1,10 @@
+import { type TSchema } from './schema.mjs';
+export type StaticUnsafe<Type extends unknown> = Type;
+/** Represents an Unsafe type. */
+export interface TUnsafe<Type extends unknown = unknown> extends TSchema {
+    '~kind': 'Unsafe';
+}
+/** Creates a Unsafe type. */
+export declare function Unsafe<Type extends unknown>(schema: TSchema): TUnsafe<Type>;
+/** Returns true if the given value is TUnsafe. */
+export declare function IsUnsafe(value: unknown): value is TUnsafe;

package/build/type/types/unsafe.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 Unsafe type. */
+export function Unsafe(schema) {
+    return Memory.Create({ ['~kind']: 'Unsafe' }, {}, schema);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TUnsafe. */
+export function IsUnsafe(value) {
+    return IsKind(value, 'Unsafe');
+}

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

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