typebox 1.0.31 → 1.0.33

package/build/cjs/type/types/parameter.d.ts

@@ -0,0 +1,17 @@
+import { type TSchema } from './schema';
+import { type TUnknown } from './unknown';
+/** Represents a Generic parameter. */
+export interface TParameter<Name extends string = string, Extends extends TSchema = TSchema, Equals extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Parameter';
+    name: Name;
+    extends: Extends;
+    equals: Equals;
+}
+/** Creates a Parameter type. */
+export declare function Parameter<Name extends string, Extends extends TSchema, Equals extends TSchema>(name: Name, extends_: Extends, equals: Equals): TParameter<Name, Extends, Equals>;
+/** Creates a Parameter type. */
+export declare function Parameter<Name extends string, Extends extends TSchema, Equals extends TSchema>(name: Name, extends_: Extends): TParameter<Name, Extends, Extends>;
+/** Creates a Parameter type. */
+export declare function Parameter<Name extends string>(name: Name): TParameter<Name, TUnknown, TUnknown>;
+/** Returns true if the given value is TParameter. */
+export declare function IsParameter(value: unknown): value is TParameter;

package/build/cjs/type/types/parameter.js

@@ -0,0 +1,25 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parameter = Parameter;
+exports.IsParameter = IsParameter;
+const index_1 = require("../../system/arguments/index");
+const index_2 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+const unknown_1 = require("./unknown");
+/** Creates a Parameter type. */
+function Parameter(...args) {
+    const [name, extends_, equals] = index_1.Arguments.Match(args, {
+        3: (name, extends_, equals) => [name, extends_, equals],
+        2: (name, extends_) => [name, extends_, extends_],
+        1: (name) => [name, (0, unknown_1.Unknown)(), (0, unknown_1.Unknown)()],
+    });
+    return index_2.Memory.Create({ '~kind': 'Parameter' }, { name, extends: extends_, equals }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TParameter. */
+function IsParameter(value) {
+    return (0, schema_1.IsKind)(value, 'Parameter');
+}

package/build/cjs/type/types/promise.d.ts

@@ -0,0 +1,16 @@
+import { type StaticType, type StaticDirection } from './static';
+import { type TSchema, type TSchemaOptions } from './schema';
+import { type TProperties } from './properties';
+export type StaticPromise<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result = Promise<StaticType<Stack, Direction, Context, This, Type>>> = Result;
+/** Represents a Promise type. */
+export interface TPromise<Type extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Promise';
+    type: 'promise';
+    item: Type;
+}
+/** Creates a Promise type. */
+export declare function Promise<Type extends TSchema>(item: Type, options?: TSchemaOptions): TPromise<Type>;
+/** Returns true if the given type is TPromise. */
+export declare function IsPromise(value: unknown): value is TPromise;
+/** Extracts options from a TPromise. */
+export declare function PromiseOptions(type: TPromise): TSchemaOptions;

package/build/cjs/type/types/promise.js

@@ -0,0 +1,29 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Promise = Promise;
+exports.IsPromise = IsPromise;
+exports.PromiseOptions = PromiseOptions;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Promise type. */
+function Promise(item, options) {
+    return index_1.Memory.Create({ ['~kind']: 'Promise' }, { type: 'promise', item }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given type is TPromise. */
+function IsPromise(value) {
+    return (0, schema_1.IsKind)(value, 'Promise');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TPromise. */
+function PromiseOptions(type) {
+    return index_1.Memory.Discard(type, ['~kind', 'type', 'item']);
+}

package/build/cjs/type/types/properties.d.ts

@@ -0,0 +1,42 @@
+import { type StaticType, type StaticDirection, type StaticEvaluate } from './static';
+import { type TSchema } from './schema';
+import { type TOptional } from './_optional';
+import { type TReadonly } from './_readonly';
+import { type TUnionToTuple } from '../engine/helpers/union';
+type ReadonlyOptionalKeys<Properties extends TProperties, Result extends PropertyKey = {
+    [Key in keyof Properties]: Properties[Key] extends TReadonly<TSchema> ? (Properties[Key] extends TOptional<Properties[Key]> ? Key : never) : never;
+}[keyof Properties]> = Result;
+type ReadonlyKeys<Properties extends TProperties, Result extends PropertyKey = {
+    [Key in keyof Properties]: Properties[Key] extends TReadonly<TSchema> ? (Properties[Key] extends TOptional<Properties[Key]> ? never : Key) : never;
+}[keyof Properties]> = Result;
+type OptionalKeys<Properties extends TProperties, Result extends PropertyKey = {
+    [Key in keyof Properties]: Properties[Key] extends TOptional<TSchema> ? (Properties[Key] extends TReadonly<Properties[Key]> ? never : Key) : never;
+}[keyof Properties]> = Result;
+type RequiredKeys<Properties extends TProperties, Result extends PropertyKey = keyof Omit<Properties, ReadonlyOptionalKeys<Properties> | ReadonlyKeys<Properties> | OptionalKeys<Properties>>> = Result;
+type StaticPropertiesWithModifiers<Properties extends TProperties, PropertiesWithoutModifiers extends Record<PropertyKey, unknown>> = StaticEvaluate<Readonly<Partial<Pick<PropertiesWithoutModifiers, ReadonlyOptionalKeys<Properties>>>> & Readonly<Pick<PropertiesWithoutModifiers, ReadonlyKeys<Properties>>> & Partial<Pick<PropertiesWithoutModifiers, OptionalKeys<Properties>>> & Required<Pick<PropertiesWithoutModifiers, RequiredKeys<Properties>>>>;
+type StaticPropertiesWithoutModifiers<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Properties extends TProperties, Result extends Record<PropertyKey, unknown> = {
+    [Key in keyof Properties]: StaticType<Stack, Direction, Context, This, Properties[Key]>;
+}> = Result;
+export type StaticProperties<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Properties extends TProperties, PropertiesWithoutModifiers extends Record<PropertyKey, unknown> = StaticPropertiesWithoutModifiers<Stack, Direction, Context, This, Properties>, PropertiesWithModifiers extends Record<PropertyKey, unknown> = StaticPropertiesWithModifiers<Properties, PropertiesWithoutModifiers>, Result extends Record<PropertyKey, unknown> = {
+    [Key in keyof PropertiesWithModifiers]: PropertiesWithModifiers[Key];
+}> = Result;
+/** Represents a Record<PropertyKey, TSchema> structure. */
+export interface TProperties extends TSchema {
+    [key: PropertyKey]: TSchema;
+}
+/** Creates a RequiredArray derived from the given TProperties value. */
+export type TRequiredArray<Properties extends TProperties, RequiredProperties extends TProperties = {
+    [Key in keyof Properties as Properties[Key] extends TOptional<Properties[Key]> ? never : Key]: Properties[Key];
+}, 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>;
+/** Extracts a tuple of keys from a TProperties value. */
+export type TPropertyKeys<Properties extends TProperties, Result extends string[] = TUnionToTuple<Extract<keyof Properties, string>>> = 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;
+/** Extracts a tuple of property values from a TProperties value. */
+export type TPropertyValues<Properties extends TProperties, Keys extends string[] = TPropertyKeys<Properties>, Result extends TSchema[] = TPropertyValuesReduce<Properties, Keys>> = Result;
+/** Extracts a tuple of property values from a TProperties value. */
+export declare function PropertyValues<Properties extends TProperties>(properties: Properties): TPropertyValues<Properties>;
+export {};

package/build/cjs/type/types/properties.js

@@ -0,0 +1,21 @@
+"use strict";
+// deno-lint-ignore-file no-array-constructor
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredArray = RequiredArray;
+exports.PropertyKeys = PropertyKeys;
+exports.PropertyValues = PropertyValues;
+const index_1 = require("../../guard/index");
+const _optional_1 = require("./_optional");
+/** Creates a RequiredArray derived from the given TProperties value. */
+function RequiredArray(properties) {
+    return index_1.Guard.Keys(properties).filter((key) => !(0, _optional_1.IsOptional)(properties[key]));
+}
+/** Extracts a tuple of keys from a TProperties value. */
+function PropertyKeys(properties) {
+    return index_1.Guard.Keys(properties);
+}
+/** Extracts a tuple of property values from a TProperties value. */
+function PropertyValues(properties) {
+    return index_1.Guard.Values(properties);
+}

package/build/cjs/type/types/record.d.ts

@@ -0,0 +1,44 @@
+import { type TSchema, type TObjectOptions } from './schema';
+import { type StaticType, type StaticDirection } from './static';
+import { type TProperties } from './properties';
+import { type TInteger } from './integer';
+import { type TNumber } from './number';
+import { type TString } from './string';
+import { type TDeferred } from './deferred';
+import { type TInstantiate } from '../engine/instantiate';
+export type StaticRecord<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Key extends string, Value extends TSchema, StaticValue extends unknown = StaticType<Stack, Direction, Context, This, Value>, Result extends Record<PropertyKey, unknown> = (Key extends TStringKey ? Record<string, StaticValue> : Key extends TIntegerKey ? Record<number, StaticValue> : Key extends TNumberKey ? Record<number, StaticValue> : Record<string, 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 StringKey = "^.*$";
+export interface TRecord<Key extends string = string, Value extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Record';
+    type: 'object';
+    patternProperties: {
+        [_ in Key]: Value;
+    };
+}
+/** Represents a deferred Record action. */
+export type TRecordDeferred<Key extends TSchema, Value extends 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>;
+/** 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 type TRecordPattern<Type extends TRecord, Result extends string = Extract<keyof Type['patternProperties'], string>> = Result;
+/** Returns the raw string pattern used for the Record key  */
+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 IntegerKey ? TInteger : Pattern extends typeof NumberKey ? TNumber : TString)> = Result;
+/** Returns the Record key as a TypeBox type  */
+export declare function RecordKey<Type extends TRecord>(type: Type): TRecordKey<Type>;
+export type TRecordValue<Type extends TRecord, Result extends TSchema = Type['patternProperties'][TRecordPattern<Type>]> = Result;
+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/cjs/type/types/record.js

@@ -0,0 +1,73 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringKey = exports.NumberKey = exports.IntegerKey = void 0;
+exports.RecordDeferred = RecordDeferred;
+exports.RecordConstruct = RecordConstruct;
+exports.Record = Record;
+exports.RecordFromPattern = RecordFromPattern;
+exports.RecordPattern = RecordPattern;
+exports.RecordKey = RecordKey;
+exports.RecordValue = RecordValue;
+exports.IsRecord = IsRecord;
+exports.RecordOptions = RecordOptions;
+const index_1 = require("../../system/memory/index");
+const index_2 = require("../../guard/index");
+const schema_1 = require("./schema");
+const integer_1 = require("./integer");
+const number_1 = require("./number");
+const string_1 = require("./string");
+const deferred_1 = require("./deferred");
+const instantiate_1 = require("../engine/instantiate");
+const record_create_1 = require("../engine/record/record-create");
+exports.IntegerKey = `^${integer_1.IntegerPattern}$`;
+exports.NumberKey = `^${number_1.NumberPattern}$`;
+exports.StringKey = `^${string_1.StringPattern}$`;
+/** Represents a deferred Record action. */
+function RecordDeferred(key, value, options = {}) {
+    return (0, deferred_1.Deferred)('Record', [key, value], options);
+}
+function RecordConstruct(key, value, options = {}) {
+    return (0, instantiate_1.Instantiate)({}, RecordDeferred(key, value, options));
+}
+// -------------------------------------------------------------------
+// Factory
+// -------------------------------------------------------------------
+/** Creates a Record type. */
+function Record(key, value, options = {}) {
+    return RecordConstruct(key, value, options);
+}
+// -------------------------------------------------------------------
+// FromPattern
+// -------------------------------------------------------------------
+/** Creates a Record type from regular expression pattern. */
+function RecordFromPattern(key, value) {
+    return (0, record_create_1.CreateRecord)(key, value);
+}
+/** Returns the raw string pattern used for the Record key  */
+function RecordPattern(type) {
+    return index_2.Guard.Keys(type.patternProperties)[0];
+}
+/** Returns the Record key as a TypeBox type  */
+function RecordKey(type) {
+    const pattern = RecordPattern(type);
+    const result = (index_2.Guard.IsEqual(pattern, exports.IntegerKey) ? (0, integer_1.Integer)() :
+        index_2.Guard.IsEqual(pattern, exports.NumberKey) ? (0, number_1.Number)() :
+            (0, string_1.String)());
+    return result;
+}
+function RecordValue(type) {
+    return type.patternProperties[RecordPattern(type)];
+}
+// -------------------------------------------------------------------
+// Guard
+// -------------------------------------------------------------------
+function IsRecord(value) {
+    return (0, schema_1.IsKind)(value, 'Record');
+}
+// -------------------------------------------------------------------
+// Options
+// -------------------------------------------------------------------
+function RecordOptions(type) {
+    return index_1.Memory.Discard(type, ['~kind', 'type', 'patternProperties']);
+}

package/build/cjs/type/types/ref.d.ts

@@ -0,0 +1,19 @@
+import { type StaticType, type StaticDirection } from './static';
+import { type TSchema, type TSchemaOptions } from './schema';
+import { type TProperties } from './properties';
+import { type TObject } from './object';
+import { type TUnknown } from './unknown';
+type CyclicStackLength<Stack extends unknown[], MaxLength extends number, Buffer extends unknown[] = []> = (Stack extends [infer Left, ...infer Right] ? Buffer['length'] extends MaxLength ? false : CyclicStackLength<Right, MaxLength, [...Buffer, Left]> : true);
+type CyclicGuard<Stack extends unknown[], Ref extends string> = (Ref extends Stack[number] ? CyclicStackLength<Stack, 2> : true);
+type StaticGuardedRef<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Ref extends string, Type extends TSchema> = (CyclicGuard<Stack, Ref> extends true ? StaticType<[...Stack, Ref], Direction, Context, This, Type> : any);
+export type StaticRef<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Ref extends string, Target extends TSchema = Ref extends keyof Context ? Context[Ref] : TUnknown, Result extends unknown = Target extends TObject ? StaticType<[], Direction, Context, This, Target> : StaticGuardedRef<Stack, Direction, Context, This, Ref, Target>> = Result;
+/** Represents a type reference. */
+export interface TRef<Ref extends string = string> extends TSchema {
+    '~kind': 'Ref';
+    $ref: Ref;
+}
+/** Creates a Ref type. */
+export declare function Ref<Ref extends string>(ref: Ref, options?: TSchemaOptions): TRef<Ref>;
+/** Returns true if the given value is TRef. */
+export declare function IsRef(value: unknown): value is TRef;
+export {};

package/build/cjs/type/types/ref.js

@@ -0,0 +1,21 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ref = Ref;
+exports.IsRef = IsRef;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Ref type. */
+function Ref(ref, options) {
+    return index_1.Memory.Create({ ['~kind']: 'Ref' }, { $ref: ref }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TRef. */
+function IsRef(value) {
+    return (0, schema_1.IsKind)(value, 'Ref');
+}

package/build/cjs/type/types/rest.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema } from '../types/schema';
+/** Represents a Rest instruction. */
+export interface TRest<Type extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Rest';
+    type: 'rest';
+    items: Type;
+}
+/** Creates a Rest instruction type. */
+export declare function Rest<Type extends TSchema>(type: Type): TRest<Type>;
+/** Returns true if the given value is TRest. */
+export declare function IsRest(value: unknown): value is TRest;

package/build/cjs/type/types/rest.js

@@ -0,0 +1,21 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rest = Rest;
+exports.IsRest = IsRest;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("../types/schema");
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+/** Creates a Rest instruction type. */
+function Rest(type) {
+    return index_1.Memory.Create({ '~kind': 'Rest' }, { type: 'rest', items: type }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TRest. */
+function IsRest(value) {
+    return (0, schema_1.IsKind)(value, 'Rest');
+}

package/build/cjs/type/types/schema.js

@@ -0,0 +1,19 @@
+"use strict";
+// deno-lint-ignore-file
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsKind = IsKind;
+exports.IsSchema = IsSchema;
+const index_1 = require("../../guard/index");
+// ------------------------------------------------------------------
+// Kind
+// ------------------------------------------------------------------
+function IsKind(value, kind) {
+    return index_1.Guard.IsObject(value) && index_1.Guard.HasPropertyKey(value, '~kind') && index_1.Guard.IsEqual(value["~kind"], kind);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+function IsSchema(value) {
+    return index_1.Guard.IsObject(value);
+}

package/build/cjs/type/types/static.d.ts

@@ -0,0 +1,47 @@
+import type { StaticCodec, TCodec } from './_codec';
+import type { StaticAny, TAny } from './any';
+import type { StaticArray, TArray } from './array';
+import type { StaticAsyncIterator, TAsyncIterator } from './async-iterator';
+import type { StaticBigInt, TBigInt } from './bigint';
+import type { StaticBoolean, TBoolean } from './boolean';
+import type { StaticConstructor, TConstructor } from './constructor';
+import type { StaticCyclic, TCyclic } from './cyclic';
+import type { StaticEnum, TEnum, TEnumValue } from './enum';
+import type { StaticFunction, TFunction } from './function';
+import type { StaticInteger, TInteger } from './integer';
+import type { StaticIntersect, TIntersect } from './intersect';
+import type { StaticIterator, TIterator } from './iterator';
+import type { StaticLiteral, TLiteral, TLiteralValue } from './literal';
+import type { StaticNever, TNever } from './never';
+import type { StaticNull, TNull } from './null';
+import type { StaticNumber, TNumber } from './number';
+import type { StaticObject, TObject } from './object';
+import type { StaticPromise, TPromise } from './promise';
+import type { TProperties } from './properties';
+import type { StaticRecord, TRecord } from './record';
+import type { StaticRef, TRef } from './ref';
+import type { TSchema } from './schema';
+import type { StaticString, TString } from './string';
+import type { StaticSymbol, TSymbol } from './symbol';
+import type { StaticTemplateLiteral, TTemplateLiteral } from './template-literal';
+import type { StaticThis, TThis } from './this';
+import type { StaticTuple, TTuple } from './tuple';
+import type { StaticUndefined, TUndefined } from './undefined';
+import type { StaticUnion, TUnion } from './union';
+import type { StaticUnknown, TUnknown } from './unknown';
+import type { StaticUnsafe, TUnsafe } from './unsafe';
+import type { StaticVoid, TVoid } from './void';
+import type { XStatic } from '../../schema/types/static';
+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 Type extends TSchema> ? StaticArray<Stack, Direction, Context, This, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? StaticAsyncIterator<Stack, Direction, Context, This, Type> : 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 Types extends TSchema[]> ? StaticTuple<Stack, Direction, Context, This, Types> : 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 = {}> = 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/cjs/type/types/static.js

@@ -0,0 +1,4 @@
+"use strict";
+// deno-lint-ignore-file
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/type/types/string.d.ts

@@ -0,0 +1,12 @@
+import { type TSchema, type TStringOptions } from './schema';
+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/cjs/type/types/string.js

@@ -0,0 +1,27 @@
+"use strict";
+// deno-lint-ignore-file
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringPattern = void 0;
+exports.String = String;
+exports.IsString = IsString;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// StringPattern
+// ------------------------------------------------------------------
+exports.StringPattern = '.*';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a String type. */
+function String(options) {
+    return index_1.Memory.Create({ '~kind': 'String' }, { type: 'string' }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TString. */
+function IsString(value) {
+    return (0, schema_1.IsKind)(value, 'String');
+}

package/build/cjs/type/types/symbol.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from './schema';
+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/cjs/type/types/symbol.js

@@ -0,0 +1,21 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Symbol = Symbol;
+exports.IsSymbol = IsSymbol;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Symbol type. */
+function Symbol(options) {
+    return index_1.Memory.Create({ '~kind': 'Symbol' }, { type: 'symbol' }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TSymbol. */
+function IsSymbol(value) {
+    return (0, schema_1.IsKind)(value, 'Symbol');
+}

package/build/cjs/type/types/template-literal.d.ts

@@ -0,0 +1,24 @@
+import { type TSchema, type TSchemaOptions } from './schema';
+import { type TDeferred } from './deferred';
+import { type TParseTemplateIntoTypes } from '../engine/patterns/template';
+import { type TInstantiate } from '../engine/instantiate';
+import { type TTemplateLiteralStatic } from '../engine/template-literal/static';
+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/cjs/type/types/template-literal.js

@@ -0,0 +1,32 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateLiteralDeferred = TemplateLiteralDeferred;
+exports.TemplateLiteralConstruct = TemplateLiteralConstruct;
+exports.TemplateLiteral = TemplateLiteral;
+exports.IsTemplateLiteral = IsTemplateLiteral;
+const index_1 = require("../../guard/index");
+const schema_1 = require("./schema");
+const deferred_1 = require("./deferred");
+const template_1 = require("../engine/patterns/template");
+const instantiate_1 = require("../engine/instantiate");
+/** Creates a deferred TemplateLiteral action. */
+function TemplateLiteralDeferred(types, options = {}) {
+    return (0, deferred_1.Deferred)('TemplateLiteral', [types], options);
+}
+function TemplateLiteralConstruct(types, options = {}) {
+    return (0, instantiate_1.Instantiate)({}, TemplateLiteralDeferred(types, options));
+}
+/** Creates a TemplateLiteral type. */
+function TemplateLiteral(input, options = {}) {
+    const types = index_1.Guard.IsString(input) ? (0, template_1.ParseTemplateIntoTypes)(input) : input;
+    return TemplateLiteralConstruct(types, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TTemplateLiteral. */
+function IsTemplateLiteral(value) {
+    return (0, schema_1.IsKind)(value, 'TemplateLiteral');
+}

package/build/cjs/type/types/this.d.ts

@@ -0,0 +1,14 @@
+import { type StaticType, type StaticDirection } from './static';
+import { type TSchema, type TSchemaOptions } from './schema';
+import { type TObject } from './object';
+import { type TProperties } from './properties';
+export type StaticThis<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties> = (StaticType<Stack, 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/cjs/type/types/this.js

@@ -0,0 +1,21 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.This = This;
+exports.IsThis = IsThis;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a This type. */
+function This(options) {
+    return index_1.Memory.Create({ ['~kind']: 'This' }, { $ref: '#' }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TThis. */
+function IsThis(value) {
+    return (0, schema_1.IsKind)(value, 'This');
+}