@depup/typebox 1.1.23-depup.0 → 1.3.8-depup.0

package/build/type/types/{iterator.mjs → dependent.mjs}

@@ -4,21 +4,21 @@ import { IsKind } from './schema.mjs';
 // ------------------------------------------------------------------
 // Factory
 // ------------------------------------------------------------------
-/** Creates a Iterator type. */
-export function Iterator(iteratorItems, options) {
-    return Memory.Create({ '~kind': 'Iterator' }, { type: 'iterator', iteratorItems }, options);
+/** Creates a Dependent type */
+export function Dependent(if_, then_, else_, options = {}) {
+    return Memory.Create({ '~kind': 'Dependent' }, { if: if_, then: then_, else: else_ }, options);
 }
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
-/** Returns true if the given value is TIterator. */
-export function IsIterator(value) {
-    return IsKind(value, 'Iterator');
+/** Returns true if the given value is TDependent. */
+export function IsDependent(value) {
+    return IsKind(value, 'Dependent');
 }
 // ------------------------------------------------------------------
 // Options
 // ------------------------------------------------------------------
-/** Extracts options from a TIterator. */
-export function IteratorOptions(type) {
-    return Memory.Discard(type, ['~kind', 'type', 'iteratorItems']);
+/** Extracts options from a IsDependent. */
+export function DependentOptions(type) {
+    return Memory.Discard(type, ['~kind', 'if', 'then', 'else']);
 }

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

@@ -1,8 +1,10 @@
 import { type TSchema, type TSchemaOptions } from './schema.mjs';
-import { type TTypeScriptEnumLike } from '../engine/enum/typescript-enum-to-enum-values.mjs';
-import { type TTypeScriptEnumToEnumValues } from '../engine/enum/typescript-enum-to-enum-values.mjs';
+import { type TTypeScriptEnumLike } from '../engine/enum/typescript_enum_to_enum_values.mjs';
+import { type TTypeScriptEnumToEnumValues } from '../engine/enum/typescript_enum_to_enum_values.mjs';
 export type StaticEnum<Values extends TEnumValue[]> = (Values[number]);
-export type TEnumValue = string | number | null;
+export type TEnumValue = string | number;
+/** Returns true if the given value is a EnumValue */
+export declare function IsEnumValue(value: unknown): value is TEnumValue;
 /** Represents an Enum type. */
 export interface TEnum<Values extends TEnumValue[] = TEnumValue[]> extends TSchema {
     '~kind': 'Enum';

package/build/type/types/enum.mjs

@@ -1,8 +1,13 @@
 // deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
 import { Memory } from '../../system/memory/index.mjs';
 import { IsKind } from './schema.mjs';
-import { IsTypeScriptEnumLike } from '../engine/enum/typescript-enum-to-enum-values.mjs';
-import { TypeScriptEnumToEnumValues } from '../engine/enum/typescript-enum-to-enum-values.mjs';
+import { IsTypeScriptEnumLike } from '../engine/enum/typescript_enum_to_enum_values.mjs';
+import { TypeScriptEnumToEnumValues } from '../engine/enum/typescript_enum_to_enum_values.mjs';
+/** Returns true if the given value is a EnumValue */
+export function IsEnumValue(value) {
+    return Guard.IsString(value) || Guard.IsNumber(value);
+}
 /** Creates an Enum type. */
 export function Enum(value, options) {
     const values = IsTypeScriptEnumLike(value) ? TypeScriptEnumToEnumValues(value) : value;

package/build/type/types/function.mjs

@@ -8,7 +8,7 @@ import { IsKind } from './schema.mjs';
 export function _Function_(parameters, returnType, options = {}) {
     return Memory.Create({ ['~kind']: 'Function' }, { type: 'function', parameters, returnType }, options);
 }
-export { _Function_ as Function };
+export { _Function_ as Function }; // Prevent Collision With Global Scope
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------

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

@@ -5,8 +5,6 @@ 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';
@@ -17,10 +15,10 @@ export * from './enum.mjs';
 export * from './function.mjs';
 export * from './generic.mjs';
 export * from './identifier.mjs';
+export * from './dependent.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';
@@ -29,7 +27,6 @@ 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';
@@ -38,7 +35,7 @@ export * from './schema.mjs';
 export * from './static.mjs';
 export * from './string.mjs';
 export * from './symbol.mjs';
-export * from './template-literal.mjs';
+export * from './template_literal.mjs';
 export * from './this.mjs';
 export * from './tuple.mjs';
 export * from './undefined.mjs';

package/build/type/types/index.mjs

@@ -11,8 +11,6 @@ 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';
@@ -23,10 +21,10 @@ export * from './enum.mjs';
 export * from './function.mjs';
 export * from './generic.mjs';
 export * from './identifier.mjs';
+export * from './dependent.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';
@@ -35,7 +33,6 @@ 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';
@@ -44,7 +41,7 @@ export * from './schema.mjs';
 export * from './static.mjs';
 export * from './string.mjs';
 export * from './symbol.mjs';
-export * from './template-literal.mjs';
+export * from './template_literal.mjs';
 export * from './this.mjs';
 export * from './tuple.mjs';
 export * from './undefined.mjs';

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

@@ -1,5 +1,5 @@
 import { type TSchema, type TNumberOptions } from './schema.mjs';
-export declare const NumberPattern = "-?(?:0|[1-9][0-9]*)(?:.[0-9]+)?";
+export declare const NumberPattern = "-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?";
 export type StaticNumber = number;
 /** Represents a Number type. */
 export interface TNumber extends TSchema {

package/build/type/types/number.mjs

@@ -4,7 +4,7 @@ import { IsKind } from './schema.mjs';
 // ------------------------------------------------------------------
 // Pattern
 // ------------------------------------------------------------------
-export const NumberPattern = '-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?';
+export const NumberPattern = '-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?';
 // ------------------------------------------------------------------
 // Factory
 // ------------------------------------------------------------------

package/build/type/types/object.mjs

@@ -11,7 +11,7 @@ export function _Object_(properties, options = {}) {
     const required = requiredKeys.length > 0 ? { required: requiredKeys } : {};
     return Memory.Create({ '~kind': 'Object' }, { type: 'object', ...required, properties }, options);
 }
-export { _Object_ as Object }; // Required for CommonJS ES Interop
+export { _Object_ as Object }; // Prevent Collision With Global Scope
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------

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

@@ -30,8 +30,9 @@ export type TRequiredArray<Properties extends TProperties, RequiredProperties ex
 }, RequiredKeys extends string[] = TUnionToTuple<Extract<keyof RequiredProperties, string>>, Result extends string[] | undefined = RequiredKeys extends [] ? undefined : RequiredKeys> = Result;
 /** Creates a RequiredArray derived from the given TProperties value. */
 export declare function RequiredArray<Properties extends TProperties>(properties: Properties): TRequiredArray<Properties>;
+type TKeyToString<Key extends number | string> = `${Key}`;
 /** Extracts a tuple of keys from a TProperties value. */
-export type TPropertyKeys<Properties extends TProperties, Result extends string[] = TUnionToTuple<Extract<keyof Properties, string>>> = Result;
+export type TPropertyKeys<Properties extends TProperties, ExtractKey extends number | string = Extract<keyof Properties, number | string>, StringKey extends string = TKeyToString<ExtractKey>, Result extends string[] = TUnionToTuple<StringKey>> = Result;
 /** Extracts a tuple of keys from a TProperties value. */
 export declare function PropertyKeys<Properties extends TProperties>(properties: Properties): TPropertyKeys<Properties>;
 type TPropertyValuesReduce<Properties extends TProperties, Keys extends string[], Result extends TSchema[] = []> = Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends keyof Properties ? TPropertyValuesReduce<Properties, Right, [...Result, Properties[Left]]> : TPropertyValuesReduce<Properties, Right, Result> : Result;

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

@@ -5,16 +5,16 @@ import { type TInteger } from './integer.mjs';
 import { type TNumber } from './number.mjs';
 import { type TString } from './string.mjs';
 import { type TDeferred } from './deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.mjs';
-import { type TTemplateLiteralStatic } from '../engine/template-literal/index.mjs';
-import { type TTemplateLiteralDecodeUnsafe } from '../engine/template-literal/decode.mjs';
+import { type TTemplateLiteralStatic } from '../engine/template_literal/index.mjs';
+import { type TTemplateLiteralDecodeUnsafe } from '../engine/template_literal/decode.mjs';
+import { type TRecordAction } from '../engine/record/instantiate.mjs';
 type StaticPropertyKey<Key extends string, Result extends PropertyKey = (Key extends TStringKey ? string : Key extends TIntegerKey ? number : Key extends TNumberKey ? number : Key extends `^${string}$` ? TTemplateLiteralStatic<Key> : string)> = Result;
-export type StaticRecord<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Key extends string, Value extends TSchema, StaticKey extends PropertyKey = StaticPropertyKey<Key>, StaticValue extends unknown = StaticType<Stack, Direction, Context, This, Value>> = Record<StaticKey, StaticValue>;
+export type StaticRecord<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Key extends string, Value extends TSchema, StaticKey extends PropertyKey = StaticPropertyKey<Key>, StaticValue extends unknown = StaticType<Stack, Direction, Context, This, Value>, Result extends Record<PropertyKey, unknown> = Record<StaticKey, StaticValue>> = Result;
 export type TStringKey = typeof StringKey;
 export type TIntegerKey = typeof IntegerKey;
 export type TNumberKey = typeof NumberKey;
 export declare const IntegerKey = "^-?(?:0|[1-9][0-9]*)$";
-export declare const NumberKey = "^-?(?:0|[1-9][0-9]*)(?:.[0-9]+)?$";
+export declare const NumberKey = "^-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?$";
 export declare const StringKey = "^.*$";
 export interface TRecord<Key extends string = string, Value extends TSchema = TSchema> extends TSchema {
     '~kind': 'Record';
@@ -24,24 +24,28 @@ export interface TRecord<Key extends string = string, Value extends TSchema = TS
     };
 }
 /** Represents a deferred Record action. */
-export type TRecordDeferred<Key extends TSchema, Value extends TSchema> = (TDeferred<'Record', [Key, Value]>);
+export type TRecordDeferred<Key extends TSchema = TSchema, Value extends TSchema = TSchema> = (TDeferred<'Record', [Key, Value]>);
 /** Represents a deferred Record action. */
 export declare function RecordDeferred<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordDeferred<Key, Value>;
-export type TRecordConstruct<Key extends TSchema, Value extends TSchema> = (TInstantiate<{}, TRecordDeferred<Key, Value>>);
-export declare function RecordConstruct<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordConstruct<Key, Value>;
 /** Creates a Record type. */
-export declare function Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordConstruct<Key, Value>;
+export declare function Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordAction<Key, Value>;
 /** Creates a Record type from regular expression pattern. */
-export declare function RecordFromPattern<Pattern extends string, Value extends TSchema>(key: Pattern, value: Value): TRecord<Pattern, Value>;
-/** Returns the raw string pattern used for the Record key  */
+export declare function RecordFromPattern<Pattern extends string, Value extends TSchema>(pattern: Pattern, value: Value): TRecord<Pattern, Value>;
+/** Transforms a Record Pattern to a Type */
+export type TRecordPatternToType<Pattern extends string, Result extends TSchema = (Pattern extends typeof StringKey ? TString : Pattern extends typeof IntegerKey ? TInteger : Pattern extends typeof NumberKey ? TNumber : TTemplateLiteralDecodeUnsafe<Pattern>)> = Result;
+/** Transforms a Record Pattern to a Type */
+export declare function RecordPatternToType<Pattern extends string>(pattern: Pattern): TRecordPatternToType<Pattern>;
+/** Extracts the Pattern from a Record type */
 export type TRecordPattern<Type extends TRecord, Result extends string = Extract<keyof Type['patternProperties'], string>> = Result;
-/** Returns the raw string pattern used for the Record key  */
+/** Extracts the Pattern from a Record type */
 export declare function RecordPattern<Type extends TRecord>(type: Type): TRecordPattern<Type>;
-/** Returns the Record key as a TypeBox type  */
-export type TRecordKey<Type extends TRecord, Pattern extends string = TRecordPattern<Type>, Result extends TSchema = (Pattern extends typeof StringKey ? TString : Pattern extends typeof IntegerKey ? TInteger : Pattern extends typeof NumberKey ? TNumber : TTemplateLiteralDecodeUnsafe<Pattern>)> = Result;
-/** Returns the Record key as a TypeBox type  */
+/** Extracts the Key from a Record type */
+export type TRecordKey<Type extends TRecord, Pattern extends string = TRecordPattern<Type>, Result extends TSchema = TRecordPatternToType<Pattern>> = Result;
+/** Extracts the Key from a Record type */
 export declare function RecordKey<Type extends TRecord>(type: Type): TRecordKey<Type>;
+/** Extracts the Value from a Record type */
 export type TRecordValue<Type extends TRecord, Result extends TSchema = Type['patternProperties'][TRecordPattern<Type>]> = Result;
+/** Extracts the Value from a Record type */
 export declare function RecordValue<Type extends TRecord>(type: Type): TRecordValue<Type>;
 export declare function IsRecord(value: unknown): value is TRecord;
 export declare function RecordOptions(type: TRecord): TObjectOptions;

package/build/type/types/record.mjs

@@ -1,4 +1,3 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
@@ -7,9 +6,9 @@ import { Integer, IntegerPattern } from './integer.mjs';
 import { Number, NumberPattern } from './number.mjs';
 import { String, StringPattern } from './string.mjs';
 import { Deferred } from './deferred.mjs';
-import { Instantiate } from '../engine/instantiate.mjs';
-import { TemplateLiteralDecodeUnsafe } from '../engine/template-literal/decode.mjs';
-import { CreateRecord } from '../engine/record/record-create.mjs';
+import { TemplateLiteralDecodeUnsafe } from '../engine/template_literal/decode.mjs';
+import { CreateRecord } from '../engine/record/record_create.mjs';
+import { RecordAction } from '../engine/record/instantiate.mjs';
 export const IntegerKey = `^${IntegerPattern}$`;
 export const NumberKey = `^${NumberPattern}$`;
 export const StringKey = `^${StringPattern}$`;
@@ -17,36 +16,39 @@ export const StringKey = `^${StringPattern}$`;
 export function RecordDeferred(key, value, options = {}) {
     return Deferred('Record', [key, value], options);
 }
-export function RecordConstruct(key, value, options = {}) {
-    return Instantiate({}, RecordDeferred(key, value, options));
-}
 // -------------------------------------------------------------------
 // Factory
 // -------------------------------------------------------------------
 /** Creates a Record type. */
 export function Record(key, value, options = {}) {
-    return RecordConstruct(key, value, options);
+    return RecordAction(key, value, options);
 }
 // -------------------------------------------------------------------
-// FromPattern
+// RecordFromPattern
 // -------------------------------------------------------------------
 /** Creates a Record type from regular expression pattern. */
-export function RecordFromPattern(key, value) {
-    return CreateRecord(key, value);
+export function RecordFromPattern(pattern, value) {
+    return CreateRecord(pattern, value);
 }
-/** Returns the raw string pattern used for the Record key  */
+/** Transforms a Record Pattern to a Type */
+export function RecordPatternToType(pattern) {
+    const result = (Guard.IsEqual(pattern, StringKey) ? String() :
+        Guard.IsEqual(pattern, IntegerKey) ? Integer() :
+            Guard.IsEqual(pattern, NumberKey) ? Number() :
+                TemplateLiteralDecodeUnsafe(pattern));
+    return result;
+}
+/** Extracts the Pattern from a Record type */
 export function RecordPattern(type) {
     return Guard.Keys(type.patternProperties)[0];
 }
-/** Returns the Record key as a TypeBox type  */
+/** Extracts the Key from a Record type */
 export function RecordKey(type) {
     const pattern = RecordPattern(type);
-    const result = (Guard.IsEqual(pattern, StringKey) ? String() :
-        Guard.IsEqual(pattern, IntegerKey) ? Integer() :
-            Guard.IsEqual(pattern, NumberKey) ? Number() :
-                TemplateLiteralDecodeUnsafe(pattern));
+    const result = RecordPatternToType(pattern);
     return result;
 }
+/** Extracts the Value from a Record type */
 export function RecordValue(type) {
     return type.patternProperties[RecordPattern(type)];
 }

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

@@ -1,8 +1,6 @@
 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 { StaticBase, Base } from './base.mjs';
 import type { StaticBigInt, TBigInt } from './bigint.mjs';
 import type { StaticBoolean, TBoolean } from './boolean.mjs';
 import type { StaticConstructor, TConstructor } from './constructor.mjs';
@@ -10,21 +8,20 @@ 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 { StaticDependent, TDependent } from './dependent.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 { 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';
@@ -37,7 +34,7 @@ export type StaticEvaluate<T> = {
     [K in keyof T]: T[K];
 } & {};
 export type StaticDirection = 'Encode' | 'Decode';
-export type StaticType<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema> = (Type extends TCodec<infer Type extends TSchema, infer Decoded extends unknown> ? StaticCodec<Stack, Direction, Context, This, Type, Decoded> : Type extends TAny ? StaticAny : Type extends TArray<infer Items extends TSchema> ? StaticArray<Stack, Direction, Context, This, Type, Items> : Type extends TAsyncIterator<infer Type extends TSchema> ? StaticAsyncIterator<Stack, Direction, Context, This, Type> : Type extends Base<infer Value extends unknown> ? StaticBase<Value> : Type extends TBigInt ? StaticBigInt : Type extends TBoolean ? StaticBoolean : Type extends TConstructor<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? StaticConstructor<Stack, 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<Stack, Direction, Context, This, Parameters, ReturnType> : Type extends TInteger ? StaticInteger : Type extends TIntersect<infer Types extends TSchema[]> ? StaticIntersect<Stack, Direction, Context, This, Types> : Type extends TIterator<infer Types extends TSchema> ? StaticIterator<Stack, 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<Stack, Direction, Context, This, Properties> : Type extends TPromise<infer Type extends TSchema> ? StaticPromise<Stack, Direction, Context, This, Type> : Type extends TRecord<infer Key extends string, infer Value extends TSchema> ? StaticRecord<Stack, Direction, Context, This, Key, Value> : Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? StaticCyclic<Stack, Direction, Context, This, Defs, Ref> : Type extends TRef<infer Ref extends string> ? StaticRef<Stack, 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<Stack, Direction, Context, This> : Type extends TTuple<infer Items extends TSchema[]> ? StaticTuple<Stack, Direction, Context, This, Type, Items> : Type extends TUndefined ? StaticUndefined : Type extends TUnion<infer Types extends TSchema[]> ? StaticUnion<Stack, Direction, Context, This, Types> : Type extends TUnknown ? StaticUnknown : Type extends TUnsafe<infer Type extends unknown> ? StaticUnsafe<Type> : Type extends TVoid ? StaticVoid : XStatic<Type>);
+export type StaticType<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema> = (Type extends TCodec<infer Type extends TSchema, infer Decoded extends unknown> ? StaticCodec<Stack, Direction, Context, This, Type, Decoded> : Type extends TAny ? StaticAny : Type extends TArray<infer Items extends TSchema> ? StaticArray<Stack, Direction, Context, This, Type, Items> : Type extends TBigInt ? StaticBigInt : Type extends TBoolean ? StaticBoolean : Type extends TConstructor<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? StaticConstructor<Stack, 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<Stack, Direction, Context, This, Parameters, ReturnType> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? StaticDependent<Stack, Direction, Context, This, If, Then, Else> : Type extends TInteger ? StaticInteger : Type extends TIntersect<infer Types extends TSchema[]> ? StaticIntersect<Stack, 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<Stack, Direction, Context, This, Properties> : Type extends TRecord<infer Key extends string, infer Value extends TSchema> ? StaticRecord<Stack, Direction, Context, This, Key, Value> : Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? StaticCyclic<Stack, Direction, Context, This, Defs, Ref> : Type extends TRef<infer Ref extends string> ? StaticRef<Stack, 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<Stack, Direction, Context, This> : Type extends TTuple<infer Items extends TSchema[]> ? StaticTuple<Stack, Direction, Context, This, Type, Items> : Type extends TUndefined ? StaticUndefined : Type extends TUnion<infer Types extends TSchema[]> ? StaticUnion<Stack, 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 = {}, Result extends unknown = StaticType<[], 'Encode', Context, {}, Type>> = Result;
 /** Infers a static type from a TypeBox type using Decode logic. */

package/build/type/types/{template-literal.d.mts → template_literal.d.mts}

@@ -1,8 +1,8 @@
 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';
+import { type TTemplateLiteralStatic } from '../engine/template_literal/static.mjs';
+import { type TTemplateLiteralAction } from '../engine/template_literal/instantiate.mjs';
 export type StaticTemplateLiteral<Pattern extends string> = (TTemplateLiteralStatic<Pattern>);
 /** Represents a TemplateLiteral type. */
 export interface TTemplateLiteral<Pattern extends string = string> extends TSchema {
@@ -11,10 +11,12 @@ export interface TTemplateLiteral<Pattern extends string = string> extends TSche
     pattern: Pattern;
 }
 /** Creates a deferred TemplateLiteral action. */
-export type TTemplateLiteralDeferred<Types extends TSchema[]> = (TDeferred<'TemplateLiteral', [Types]>);
+export type TTemplateLiteralDeferred<Types extends TSchema[] = TSchema[]> = (TDeferred<'TemplateLiteral', [Types]>);
 /** Creates a deferred TemplateLiteral action. */
 export declare function TemplateLiteralDeferred<Types extends TSchema[]>(types: [...Types], options?: TSchemaOptions): TTemplateLiteralDeferred<Types>;
-export type TTemplateLiteralFromTypes<Types extends TSchema[], Result extends TSchema = TInstantiate<{}, TTemplateLiteralDeferred<Types>>> = Result;
+/** Returns true if this value is a deferred Interface action. */
+export declare function IsTemplateLiteralDeferred(value: unknown): value is TTemplateLiteralDeferred;
+export type TTemplateLiteralFromTypes<Types extends TSchema[], Result extends TSchema = TTemplateLiteralAction<Types>> = Result;
 export declare function TemplateLiteralFromTypes<Types extends TSchema[]>(types: [...Types]): TTemplateLiteralFromTypes<Types>;
 export type TTemplateLiteralFromString<Template extends string, Types extends TSchema[] = TParseTemplateIntoTypes<Template>, Result extends TSchema = TTemplateLiteralFromTypes<Types>> = Result;
 export declare function TemplateLiteralFromString<Template extends string>(template: Template): TTemplateLiteralFromString<Template>;

package/build/type/types/{template-literal.mjs → template_literal.mjs}

@@ -1,17 +1,23 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file
+import { Memory } from '../../system/system.mjs';
 import { Guard } from '../../guard/index.mjs';
-import { IsKind } from './schema.mjs';
+import { IsSchema, IsKind } from './schema.mjs';
 import { Deferred } from './deferred.mjs';
 import { ParseTemplateIntoTypes } from '../engine/patterns/template.mjs';
-import { Instantiate } from '../engine/instantiate.mjs';
-import { Memory } from '../../system/system.mjs';
+import { TemplateLiteralAction } from '../engine/template_literal/instantiate.mjs';
 /** Creates a deferred TemplateLiteral action. */
 export function TemplateLiteralDeferred(types, options = {}) {
     return Deferred('TemplateLiteral', [types], options);
 }
+/** Returns true if this value is a deferred Interface action. */
+export function IsTemplateLiteralDeferred(value) {
+    return IsSchema(value)
+        && Guard.HasPropertyKey(value, 'action')
+        && Guard.IsEqual(value.action, 'TemplateLiteral');
+}
 export function TemplateLiteralFromTypes(types) {
-    return Instantiate({}, TemplateLiteralDeferred(types, {}));
+    return TemplateLiteralAction(types, {});
 }
 export function TemplateLiteralFromString(template) {
     const types = ParseTemplateIntoTypes(template);

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

@@ -2,8 +2,7 @@ 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';
-    '~hint': Type;
+    '~unsafe': Type;
 }
 /** Creates a Unsafe type. */
 export declare function Unsafe<Type extends unknown>(schema: TSchema): TUnsafe<Type>;

package/build/type/types/unsafe.mjs

@@ -1,18 +1,20 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file 
+import { Guard } from '../../guard/index.mjs';
 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);
+    return Memory.Update(schema, { ['~unsafe']: null }, {});
 }
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
 /** Returns true if the given value is TUnsafe. */
 export function IsUnsafe(value) {
-    return IsKind(value, 'Unsafe');
+    return Guard.IsObjectNotArray(value)
+        && Guard.HasPropertyKey(value, '~unsafe')
+        && Guard.IsNull(value['~unsafe']);
 }

package/build/typebox.d.mts

@@ -1,69 +1,65 @@
 export { Instantiate, type TInstantiate } from './type/engine/instantiate.mjs';
 export { Extends, ExtendsResult, type TExtends } from './type/extends/index.mjs';
 export { Script, type TScript } from './type/script/index.mjs';
-export { Awaited, type AwaitedDeferred, type TAwaited } from './type/action/awaited.mjs';
 export { Capitalize, type TCapitalize, type TCapitalizeDeferred } from './type/action/capitalize.mjs';
 export { Conditional, type TConditional, type TConditionalDeferred } from './type/action/conditional.mjs';
-export { ConstructorParameters, type TConstructorParameters, type TConstructorParametersDeferred } from './type/action/constructor-parameters.mjs';
+export { ConstructorParameters, type TConstructorParameters, type TConstructorParametersDeferred } from './type/action/constructor_parameters.mjs';
 export { Evaluate, type TEvaluate, type TEvaluateDeferred } from './type/action/evaluate.mjs';
 export { Exclude, type TExclude, type TExcludeDeferred } from './type/action/exclude.mjs';
 export { Extract, type TExtract, type TExtractDeferred } from './type/action/extract.mjs';
 export { Index, type TIndex, type TIndexDeferred } from './type/action/index.mjs';
-export { InstanceType, type TInstanceType, type TInstanceTypeDeferred } from './type/action/instance-type.mjs';
+export { InstanceType, type TInstanceType, type TInstanceTypeDeferred } from './type/action/instance_type.mjs';
 export { Interface, type TInterface, type TInterfaceDeferred } from './type/action/interface.mjs';
 export { KeyOf, type TKeyOf, type TKeyOfDeferred } from './type/action/keyof.mjs';
 export { Lowercase, type TLowercase, type TLowercaseDeferred } from './type/action/lowercase.mjs';
 export { Mapped, type TMapped, type TMappedDeferred } from './type/action/mapped.mjs';
 export { Module, type TModule, type TModuleDeferred } from './type/action/module.mjs';
-export { NonNullable, type TNonNullable, type TNonNullableDeferred } from './type/action/non-nullable.mjs';
+export { NonNullable, type TNonNullable, type TNonNullableDeferred } from './type/action/non_nullable.mjs';
 export { Omit, type TOmit, type TOmitDeferred } from './type/action/omit.mjs';
-export { Options, type TOptions } from './type/action/options.mjs';
 export { Parameters, type TParameters, type TParametersDeferred } from './type/action/parameters.mjs';
 export { Partial, type TPartial, type TPartialDeferred } from './type/action/partial.mjs';
 export { Pick, type TPick, type TPickDeferred } from './type/action/pick.mjs';
-export { ReadonlyType, type TReadonlyType, type TReadonlyTypeDeferred } from './type/action/readonly-type.mjs';
+export { ReadonlyObject, ReadonlyType, type TReadonlyObject, type TReadonlyObjectDeferred } from './type/action/readonly_object.mjs';
 export { Required, type TRequired, type TRequiredDeferred } from './type/action/required.mjs';
-export { ReturnType, type TReturnType, type TReturnTypeDeferred } from './type/action/return-type.mjs';
+export { ReturnType, type TReturnType, type TReturnTypeDeferred } from './type/action/return_type.mjs';
 export { type TUncapitalize, type TUncapitalizeDeferred, Uncapitalize } from './type/action/uncapitalize.mjs';
 export { type TUppercase, type TUppercaseDeferred, Uppercase } from './type/action/uppercase.mjs';
+export { type TWith, With } from './type/action/with.mjs';
 export { Codec, Decode, DecodeBuilder, Encode, EncodeBuilder, IsCodec, type TCodec } from './type/types/_codec.mjs';
 export { Immutable, IsImmutable, type TImmutable } from './type/types/_immutable.mjs';
 export { IsOptional, Optional, type TOptional } from './type/types/_optional.mjs';
 export { IsReadonly, Readonly, type TReadonly } from './type/types/_readonly.mjs';
-export { IsRefine, Refine, type TRefine, type TRefineCallback, type TRefinement } from './type/types/_refine.mjs';
+export { IsRefine, Refine, type TRefine, type TRefineCheckCallback, type TRefineErrorCallback, type TRefinement } from './type/types/_refine.mjs';
 export { Any, IsAny, type TAny } from './type/types/any.mjs';
 export { Array, IsArray, type TArray } from './type/types/array.mjs';
-export { AsyncIterator, IsAsyncIterator, type TAsyncIterator } from './type/types/async-iterator.mjs';
-export { Base, IsBase } from './type/types/base.mjs';
 export { BigInt, IsBigInt, type TBigInt } from './type/types/bigint.mjs';
 export { Boolean, IsBoolean, type TBoolean } from './type/types/boolean.mjs';
 export { Call, IsCall, type TCall } from './type/types/call.mjs';
 export { Constructor, IsConstructor, type TConstructor } from './type/types/constructor.mjs';
 export { Cyclic, IsCyclic, type TCyclic } from './type/types/cyclic.mjs';
-export { Enum, IsEnum, type TEnum, type TEnumValue } from './type/types/enum.mjs';
+export { Enum, IsEnum, IsEnumValue, type TEnum, type TEnumValue } from './type/types/enum.mjs';
 export { Function, IsFunction, type TFunction } from './type/types/function.mjs';
 export { Generic, IsGeneric, type TGeneric } from './type/types/generic.mjs';
 export { Identifier, IsIdentifier, type TIdentifier } from './type/types/identifier.mjs';
+export { Dependent, IsDependent, type TDependent } from './type/types/dependent.mjs';
 export { Infer, IsInfer, type TInfer } from './type/types/infer.mjs';
 export { Integer, IsInteger, type TInteger } from './type/types/integer.mjs';
 export { Intersect, IsIntersect, type TIntersect } from './type/types/intersect.mjs';
-export { IsIterator, Iterator, type TIterator } from './type/types/iterator.mjs';
 export { IsLiteral, Literal, type TLiteral, type TLiteralValue } from './type/types/literal.mjs';
 export { IsNever, Never, type TNever } from './type/types/never.mjs';
 export { IsNull, Null, type TNull } from './type/types/null.mjs';
 export { IsNumber, Number, type TNumber } from './type/types/number.mjs';
 export { IsObject, Object, type TObject } from './type/types/object.mjs';
 export { IsParameter, Parameter, type TParameter } from './type/types/parameter.mjs';
-export { IsPromise, Promise, type TPromise } from './type/types/promise.mjs';
 export { type TProperties, type TRequiredArray } from './type/types/properties.mjs';
-export { IsRecord, Record, RecordKey, RecordPattern as RecordKeyAsPattern, RecordValue, type TRecord, type TRecordKey as TRecordKey, type TRecordPattern as TRecordKeyAsPattern, type TRecordValue } from './type/types/record.mjs';
+export { IsRecord, Record, RecordKey, RecordPattern, RecordValue, type TRecord, type TRecordKey, type TRecordPattern, type TRecordValue } from './type/types/record.mjs';
 export { IsRef, Ref, type TRef } from './type/types/ref.mjs';
 export { IsRest, Rest, type TRest } from './type/types/rest.mjs';
 export { IsKind, IsSchema, type TArrayOptions, type TFormat, type TIntersectOptions, type TNumberOptions, type TObjectOptions, type TSchema, type TSchemaOptions, type TStringOptions, type TTupleOptions } from './type/types/schema.mjs';
 export { type Static, type StaticDecode, type StaticEncode, type StaticParse } from './type/types/static.mjs';
 export { IsString, String, type TString } from './type/types/string.mjs';
 export { IsSymbol, Symbol, type TSymbol } from './type/types/symbol.mjs';
-export { IsTemplateLiteral, TemplateLiteral, type TTemplateLiteral } from './type/types/template-literal.mjs';
+export { IsTemplateLiteral, TemplateLiteral, type TTemplateLiteral } from './type/types/template_literal.mjs';
 export { IsThis, This, type TThis } from './type/types/this.mjs';
 export { IsTuple, type TTuple, Tuple } from './type/types/tuple.mjs';
 export { IsUndefined, type TUndefined, Undefined } from './type/types/undefined.mjs';