typebox 0.0.1 → 1.0.0-rc

package/build/type/types/call.mjs

@@ -0,0 +1,21 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+import { CallInstantiate } from '../engine/call/instantiate.mjs';
+export function CallConstruct(target, arguments_) {
+    return Memory.Create({ ['~kind']: 'Call' }, { target, arguments: arguments_ }, {});
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Call type. */
+export function Call(target, arguments_) {
+    return CallInstantiate({}, { callstack: [] }, target, arguments_);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given type is a TCall. */
+export function IsCall(value) {
+    return IsKind(value, 'Call');
+}

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

@@ -0,0 +1,18 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+import { type StaticTuple } from './tuple.mjs';
+export type StaticConstructor<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, StaticParameters extends unknown[] = StaticTuple<Direction, Context, This, Parameters>, StaticReturnType extends unknown = StaticType<Direction, Context, This, InstanceType>, Result = new (...args: StaticParameters) => StaticReturnType> = Result;
+/** Represents a Constructor type. */
+export interface TConstructor<Parameters extends TSchema[] = TSchema[], InstanceType extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Constructor';
+    type: 'constructor';
+    parameters: Parameters;
+    instanceType: InstanceType;
+}
+/** Creates a Constructor type. */
+export declare function Constructor<Parameters extends TSchema[], InstanceType extends TSchema>(parameters: [...Parameters], instanceType: InstanceType, options?: TSchemaOptions): TConstructor<Parameters, InstanceType>;
+/** Returns true if the given value is a TConstructor. */
+export declare function IsConstructor(value: unknown): value is TConstructor;
+/** Extracts options from a TConstructor. */
+export declare function ConstructorOptions(type: TConstructor): TSchemaOptions;

package/build/type/types/constructor.mjs

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

package/build/type/types/cyclic.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 StaticCyclic<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Defs extends TProperties, Ref extends string, Result extends unknown = Ref extends keyof Defs ? StaticType<Direction, Defs, This, Defs[Ref]> : never> = Result;
+/** Represents a Cyclic type. */
+export interface TCyclic<Defs extends TProperties = TProperties, Ref extends string = string> extends TSchema {
+    '~kind': 'Cyclic';
+    $defs: Defs;
+    $ref: Ref;
+}
+/** Creates a Cyclic type. */
+export declare function Cyclic<Defs extends TProperties, Ref extends string>($defs: Defs, $ref: Ref, options?: TSchemaOptions): TCyclic<Defs, Ref>;
+/** Returns true if the given value is a TCyclic. */
+export declare function IsCyclic(value: unknown): value is TCyclic;
+/** Extracts options from a TCyclic. */
+export declare function CyclicOptions(type: TCyclic): TSchemaOptions;

package/build/type/types/cyclic.mjs

@@ -0,0 +1,29 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Cyclic type. */
+export function Cyclic($defs, $ref, options) {
+    // $defs require an $id per definition to enable Ajv to resolve correctly
+    const defs = Guard.Keys($defs).reduce((result, key) => {
+        return { ...result, [key]: Memory.Update($defs[key], {}, { $id: key }) };
+    }, {});
+    return Memory.Create({ ['~kind']: 'Cyclic' }, { $defs: defs, $ref }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TCyclic. */
+export function IsCyclic(value) {
+    return IsKind(value, 'Cyclic');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TCyclic. */
+export function CyclicOptions(type) {
+    return Memory.Discard(type, ['~kind', '$defs', '$ref']);
+}

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+/** Represents a deferred action. */
+export interface TDeferred<Action extends string = string, Types extends TSchema[] = TSchema[]> extends TSchema {
+    '~kind': 'Deferred';
+    action: Action;
+    parameters: Types;
+    options: TSchemaOptions;
+}
+/** Creates a Deferred action. */
+export declare function Deferred<Action extends string, Types extends TSchema[]>(action: Action, parameters: [...Types], options: TSchemaOptions): TDeferred<Action, Types>;
+/** Returns true if the given value is a TDeferred. */
+export declare function IsDeferred(value: unknown): value is TDeferred;

package/build/type/types/deferred.mjs

@@ -0,0 +1,16 @@
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Deferred action. */
+export function Deferred(action, parameters, options) {
+    return Memory.Create({ '~kind': 'Deferred' }, { action, parameters, options }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TDeferred. */
+export function IsDeferred(value) {
+    return IsKind(value, 'Deferred');
+}

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

@@ -0,0 +1,15 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TTSEnumToEnumValues, type TTSEnumLike } from '../engine/enum/typescript-enum-to-enum-values.mjs';
+export type StaticEnum<Values extends TEnumValue[]> = (Values[number]);
+export type TEnumValue = string | number | null;
+/** Represents an Enum type. */
+export interface TEnum<Values extends TEnumValue[] = TEnumValue[]> extends TSchema {
+    '~kind': 'Enum';
+    enum: Values;
+}
+/** Creates an Enum type. */
+export declare function Enum<Enum extends TTSEnumLike>(value: Enum, options?: TSchemaOptions): TEnum<TTSEnumToEnumValues<Enum>>;
+/** Creates an Enum type. */
+export declare function Enum<Values extends TEnumValue[]>(values: [...Values], options?: TSchemaOptions): TEnum<Values>;
+/** Returns true if the given value is a TEnum. */
+export declare function IsEnum(value: unknown): value is TEnum;

package/build/type/types/enum.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsKind } from './schema.mjs';
+import { TSEnumToEnumValues } from '../engine/enum/typescript-enum-to-enum-values.mjs';
+/** Creates an Enum type. */
+export function Enum(value, options) {
+    const values = Guard.IsArray(value) ? value : TSEnumToEnumValues(value);
+    return Memory.Create({ '~kind': 'Enum' }, { enum: values }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TEnum. */
+export function IsEnum(value) {
+    return IsKind(value, 'Enum');
+}

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

@@ -0,0 +1,18 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+import { type StaticTuple } from './tuple.mjs';
+export type StaticFunction<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema, StaticParameters extends unknown[] = StaticTuple<Direction, Context, This, Parameters>, StaticReturnType extends unknown = StaticType<Direction, Context, This, ReturnType>, Result = (...args: StaticParameters) => StaticReturnType> = Result;
+/** Represents a Function type. */
+export interface TFunction<Parameters extends TSchema[] = TSchema[], ReturnType extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Function';
+    type: 'function';
+    parameters: Parameters;
+    returnType: ReturnType;
+}
+/** Creates a Function type. */
+export declare function Function<Parameters extends TSchema[], ReturnType extends TSchema>(parameters: [...Parameters], returnType: ReturnType, options?: TSchemaOptions): TFunction<Parameters, ReturnType>;
+/** Returns true if the given value is TFunction. */
+export declare function IsFunction(value: unknown): value is TFunction;
+/** Extracts options from a TFunction. */
+export declare function FunctionOptions(type: TFunction): TSchemaOptions;

package/build/type/types/function.mjs

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

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

@@ -0,0 +1,13 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TParameter } from './parameter.mjs';
+/** Represents a callable Generic type. */
+export interface TGeneric<Parameters extends TParameter[] = TParameter[], Expression extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Generic';
+    type: 'generic';
+    parameters: Parameters;
+    expression: Expression;
+}
+/** Creates a Generic type. */
+export declare function Generic<Parameters extends TParameter[], Expression extends TSchema>(parameters: [...Parameters], expression: Expression): TGeneric<Parameters, Expression>;
+/** Returns true if the given value is a TGeneric. */
+export declare function IsGeneric(value: unknown): value is TGeneric;

package/build/type/types/generic.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from '../types/schema.mjs';
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+/** Creates a Generic type. */
+export function Generic(parameters, expression) {
+    return Memory.Create({ '~kind': 'Generic' }, { type: 'generic', parameters, expression });
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TGeneric. */
+export function IsGeneric(value) {
+    return IsKind(value, 'Generic');
+}

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

@@ -0,0 +1,11 @@
+import { type TSchema } from '../types/schema.mjs';
+/** Represents a Identifier. */
+export interface TIdentifier<Name extends string = string> extends TSchema {
+    '~kind': 'Identifier';
+    type: 'identifier';
+    name: Name;
+}
+/** Creates an Identifier. */
+export declare function Identifier<Name extends string>(name: Name): TIdentifier<Name>;
+/** Returns true if the given value is a TIdentifier. */
+export declare function IsIdentifier(value: unknown): value is TIdentifier;

package/build/type/types/identifier.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from '../types/schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates an Identifier. */
+export function Identifier(name) {
+    return Memory.Create({ '~kind': 'Identifier' }, { name });
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TIdentifier. */
+export function IsIdentifier(value) {
+    return IsKind(value, 'Identifier');
+}

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

@@ -0,0 +1,47 @@
+export * from './_codec.mjs';
+export * from './_optional.mjs';
+export * from './_readonly.mjs';
+export * from './_refine.mjs';
+export * from './any.mjs';
+export * from './array.mjs';
+export * from './async-iterator.mjs';
+export * from './base.mjs';
+export * from './bigint.mjs';
+export * from './boolean.mjs';
+export * from './call.mjs';
+export * from './constructor.mjs';
+export * from './cyclic.mjs';
+export * from './deferred.mjs';
+export * from './enum.mjs';
+export * from './function.mjs';
+export * from './generic.mjs';
+export * from './identifier.mjs';
+export * from './infer.mjs';
+export * from './integer.mjs';
+export * from './intersect.mjs';
+export * from './iterator.mjs';
+export * from './literal.mjs';
+export * from './never.mjs';
+export * from './null.mjs';
+export * from './number.mjs';
+export * from './unknown.mjs';
+export * from './symbol.mjs';
+export * from './object.mjs';
+export * from './parameter.mjs';
+export * from './promise.mjs';
+export * from './properties.mjs';
+export * from './record.mjs';
+export * from './ref.mjs';
+export * from './rest.mjs';
+export * from './schema.mjs';
+export * from './static.mjs';
+export * from './string.mjs';
+export * from './symbol.mjs';
+export * from './template-literal.mjs';
+export * from './this.mjs';
+export * from './tuple.mjs';
+export * from './undefined.mjs';
+export * from './union.mjs';
+export * from './unknown.mjs';
+export * from './unsafe.mjs';
+export * from './void.mjs';

package/build/type/types/index.mjs

@@ -0,0 +1,53 @@
+// ------------------------------------------------------------------
+// Extensions
+// ------------------------------------------------------------------
+export * from './_codec.mjs';
+export * from './_optional.mjs';
+export * from './_readonly.mjs';
+export * from './_refine.mjs';
+// ------------------------------------------------------------------
+// Standard
+// ------------------------------------------------------------------
+export * from './any.mjs';
+export * from './array.mjs';
+export * from './async-iterator.mjs';
+export * from './base.mjs';
+export * from './bigint.mjs';
+export * from './boolean.mjs';
+export * from './call.mjs';
+export * from './constructor.mjs';
+export * from './cyclic.mjs';
+export * from './deferred.mjs';
+export * from './enum.mjs';
+export * from './function.mjs';
+export * from './generic.mjs';
+export * from './identifier.mjs';
+export * from './infer.mjs';
+export * from './integer.mjs';
+export * from './intersect.mjs';
+export * from './iterator.mjs';
+export * from './literal.mjs';
+export * from './never.mjs';
+export * from './null.mjs';
+export * from './number.mjs';
+export * from './unknown.mjs';
+export * from './symbol.mjs';
+export * from './object.mjs';
+export * from './parameter.mjs';
+export * from './promise.mjs';
+export * from './properties.mjs';
+export * from './record.mjs';
+export * from './ref.mjs';
+export * from './rest.mjs';
+export * from './schema.mjs';
+export * from './static.mjs';
+export * from './string.mjs';
+export * from './symbol.mjs';
+export * from './template-literal.mjs';
+export * from './this.mjs';
+export * from './tuple.mjs';
+export * from './undefined.mjs';
+export * from './union.mjs';
+export * from './unknown.mjs';
+export * from './unsafe.mjs';
+export * from './void.mjs';

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

@@ -0,0 +1,15 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+/** Represents an Infer instruction. */
+export interface TInfer<Name extends string = string, Extends extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Infer';
+    type: 'infer';
+    name: Name;
+    extends: Extends;
+}
+/** Creates an Infer instruction. */
+export declare function Infer<Name extends string, Extends extends TSchema>(name: Name, extends_: Extends): TInfer<Name, Extends>;
+/** Creates an Infer instruction. */
+export declare function Infer<Name extends string>(name: Name): TInfer<Name, TUnknown>;
+/** Returns true if the given value is TInfer. */
+export declare function IsInfer(value: unknown): value is TInfer;

package/build/type/types/infer.mjs

@@ -0,0 +1,20 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from '../types/schema.mjs';
+import { Unknown } from '../types/unknown.mjs';
+/** Creates an Infer instruction. */
+export function Infer(...args) {
+    const [name, extends_] = Arguments.Match(args, {
+        2: (name, extends_) => [name, extends_, extends_],
+        1: (name) => [name, Unknown(), Unknown()],
+    });
+    return Memory.Create({ ['~kind']: 'Infer' }, { type: 'infer', name, extends: extends_ }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TInfer. */
+export function IsInfer(value) {
+    return IsKind(value, 'Infer');
+}

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TNumberOptions } from './schema.mjs';
+export declare const IntegerPattern = "-?(?:0|[1-9][0-9]*)";
+export type StaticInteger = number;
+/** Represents an integer type. */
+export interface TInteger extends TSchema {
+    '~kind': 'Integer';
+    type: 'integer';
+}
+/** Creates a Integer type. */
+export declare function Integer(options?: TNumberOptions): TInteger;
+/** Returns true if the given value is TInteger. */
+export declare function IsInteger(value: unknown): value is TInteger;

package/build/type/types/integer.mjs

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

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

@@ -0,0 +1,15 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TIntersectOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticIntersect<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Types extends TSchema[], Result extends unknown = unknown> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? StaticIntersect<Direction, Context, This, Right, Result & StaticType<Direction, Context, This, Left>> : Result);
+/** Represents a logical Intersect type. */
+export interface TIntersect<Types extends TSchema[] = TSchema[]> extends TSchema {
+    '~kind': 'Intersect';
+    allOf: Types;
+}
+/** Creates a Intersect type. */
+export declare function Intersect<Types extends TSchema[]>(types: [...Types], options?: TIntersectOptions): TIntersect<Types>;
+/** Returns true if the given value is TIntersect. */
+export declare function IsIntersect(value: unknown): value is TIntersect;
+/** Extracts options from a TIntersect. */
+export declare function IntersectOptions(type: TIntersect): TIntersectOptions;

package/build/type/types/intersect.mjs

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

package/build/type/types/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 StaticIterator<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result = IterableIterator<StaticType<Direction, Context, This, Type>>> = Result;
+/** Represents an Iterator. */
+export interface TIterator<Type extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Iterator';
+    type: 'iterator';
+    iteratorItems: Type;
+}
+/** Creates a Iterator type. */
+export declare function Iterator<Type extends TSchema>(iteratorItems: Type, options?: TSchemaOptions): TIterator<Type>;
+/** Returns true if the given value is TIterator. */
+export declare function IsIterator(value: unknown): value is TIterator;
+/** Extracts options from a TIterator. */
+export declare function IteratorOptions(type: TIterator): TSchemaOptions;

package/build/type/types/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 Iterator type. */
+export function Iterator(iteratorItems, options) {
+    return Memory.Create({ '~kind': 'Iterator' }, { type: 'iterator', iteratorItems }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TIterator. */
+export function IsIterator(value) {
+    return IsKind(value, 'Iterator');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TIterator. */
+export function IteratorOptions(type) {
+    return Memory.Discard(type, ['~kind', 'type', 'iteratorItems']);
+}

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

@@ -0,0 +1,22 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+export type StaticLiteral<Value extends TLiteralValue> = (Value);
+export type TLiteralValue = string | number | boolean | bigint;
+/** Represents a Literal type. */
+export interface TLiteral<Value extends TLiteralValue = TLiteralValue> extends TSchema {
+    '~kind': 'Literal';
+    const: Value;
+}
+/** Creates a Literal type. */
+export declare function Literal<Value extends TLiteralValue>(value: Value, options?: TSchemaOptions): TLiteral<Value>;
+/** Returns true if the given value is a TLiteralValue. */
+export declare function IsLiteralValue(value: unknown): value is TLiteralValue;
+/** Returns true if the given value is TLiteral<bigint>. */
+export declare function IsLiteralBigInt(value: unknown): value is TLiteral<bigint>;
+/** Returns true if the given value is TLiteral<boolean>. */
+export declare function IsLiteralBoolean(value: unknown): value is TLiteral<boolean>;
+/** Returns true if the given value is TLiteral<number>. */
+export declare function IsLiteralNumber(value: unknown): value is TLiteral<number>;
+/** Returns true if the given value is TLiteral<string>. */
+export declare function IsLiteralString(value: unknown): value is TLiteral<string>;
+/** Returns true if the given value is TLiteral. */
+export declare function IsLiteral(value: unknown): value is TLiteral;

package/build/type/types/literal.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Literal type. */
+export function Literal(value, options) {
+    return Memory.Create({ '~kind': 'Literal' }, { const: value }, options);
+}
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TLiteralValue. */
+export function IsLiteralValue(value) {
+    return Guard.IsBigInt(value)
+        || Guard.IsBoolean(value)
+        || Guard.IsNumber(value)
+        || Guard.IsString(value);
+}
+/** Returns true if the given value is TLiteral<bigint>. */
+export function IsLiteralBigInt(value) {
+    return IsLiteral(value) && Guard.IsBigInt(value.const);
+}
+/** Returns true if the given value is TLiteral<boolean>. */
+export function IsLiteralBoolean(value) {
+    return IsLiteral(value) && Guard.IsBoolean(value.const);
+}
+/** Returns true if the given value is TLiteral<number>. */
+export function IsLiteralNumber(value) {
+    return IsLiteral(value) && Guard.IsNumber(value.const);
+}
+/** Returns true if the given value is TLiteral<string>. */
+export function IsLiteralString(value) {
+    return IsLiteral(value) && Guard.IsString(value.const);
+}
+/** Returns true if the given value is TLiteral. */
+export function IsLiteral(value) {
+    return IsKind(value, 'Literal');
+}

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+export declare const NeverPattern = "(?!)";
+export type StaticNever = never;
+/** Represents a Never type. */
+export interface TNever extends TSchema {
+    '~kind': 'Never';
+    not: {};
+}
+/** Creates a Never type. */
+export declare function Never(options?: TSchemaOptions): TNever;
+/** Returns true if the given value is TNever. */
+export declare function IsNever(value: unknown): value is TNever;