@sinclair/typebox 0.32.0-dev-16 → 0.32.0-dev-18

package/build/import/compiler/compiler.d.mts

@@ -9,10 +9,15 @@ export declare class TypeCheck<T extends TSchema> {
     private readonly code;
     private readonly hasTransform;
     constructor(schema: T, references: TSchema[], checkFunc: CheckFunction, code: string);
+    /** Returns the generated assertion code used to validate this type. */
     Code(): string;
+    /** Returns an iterator for each error in this value. */
     Errors(value: unknown): ValueErrorIterator;
+    /** Returns true if the value matches the compiled type. */
     Check(value: unknown): value is Static<T>;
+    /** Decodes a value or throws if error */
     Decode(value: unknown): StaticDecode<T>;
+    /** Encodes a value or throws if error */
     Encode(value: unknown): StaticEncode<T>;
 }
 export declare class TypeCompilerUnknownTypeError extends Error {
@@ -34,8 +39,12 @@ export type TypeCompilerLanguageOption = 'typescript' | 'javascript';
 export interface TypeCompilerCodegenOptions {
     language?: TypeCompilerLanguageOption;
 }
+/** Compiles Types for Runtime Type Checking */
 export declare namespace TypeCompiler {
+    /** Generates the code used to assert this type and returns it as a string */
     function Code<T extends TSchema>(schema: T, references: TSchema[], options?: TypeCompilerCodegenOptions): string;
+    /** Generates the code used to assert this type and returns it as a string */
     function Code<T extends TSchema>(schema: T, options?: TypeCompilerCodegenOptions): string;
+    /** Compiles a TypeBox type for optimal runtime type checking. Types must be valid TypeBox types of TSchema */
     function Compile<T extends TSchema>(schema: T, references?: TSchema[]): TypeCheck<T>;
 }

package/build/import/compiler/compiler.mjs

@@ -10,6 +10,9 @@ import { TypeRegistry, FormatRegistry } from '../type/registry/index.mjs';
 import { KeyOfPattern } from '../type/keyof/index.mjs';
 import { ExtendsUndefinedCheck } from '../type/extends/extends-undefined.mjs';
 import { Never } from '../type/never/index.mjs';
+// ------------------------------------------------------------------
+// TypeCheck
+// ------------------------------------------------------------------
 export class TypeCheck {
     schema;
     references;
@@ -23,20 +26,25 @@ export class TypeCheck {
         this.code = code;
         this.hasTransform = HasTransform(schema, references);
     }
+    /** Returns the generated assertion code used to validate this type. */
     Code() {
         return this.code;
     }
+    /** Returns an iterator for each error in this value. */
     Errors(value) {
         return Errors(this.schema, this.references, value);
     }
+    /** Returns true if the value matches the compiled type. */
     Check(value) {
         return this.checkFunc(value);
     }
+    /** Decodes a value or throws if error */
     Decode(value) {
         if (!this.checkFunc(value))
             throw new TransformDecodeCheckError(this.schema, value, this.Errors(value).First());
         return this.hasTransform ? TransformDecode(this.schema, this.references, value) : value;
     }
+    /** Encodes a value or throws if error */
     Encode(value) {
         const encoded = this.hasTransform ? TransformEncode(this.schema, this.references, value) : value;
         if (!this.checkFunc(encoded))
@@ -44,6 +52,9 @@ export class TypeCheck {
         return encoded;
     }
 }
+// ------------------------------------------------------------------
+// Character
+// ------------------------------------------------------------------
 var Character;
 (function (Character) {
     function DollarSign(code) {
@@ -63,6 +74,9 @@ var Character;
     }
     Character.IsNumeric = IsNumeric;
 })(Character || (Character = {}));
+// ------------------------------------------------------------------
+// MemberExpression
+// ------------------------------------------------------------------
 var MemberExpression;
 (function (MemberExpression) {
     function IsFirstCharacterNumeric(value) {
@@ -89,6 +103,9 @@ var MemberExpression;
     }
     MemberExpression.Encode = Encode;
 })(MemberExpression || (MemberExpression = {}));
+// ------------------------------------------------------------------
+// Identifier
+// ------------------------------------------------------------------
 var Identifier;
 (function (Identifier) {
     function Encode($id) {
@@ -106,6 +123,9 @@ var Identifier;
     }
     Identifier.Encode = Encode;
 })(Identifier || (Identifier = {}));
+// ------------------------------------------------------------------
+// LiteralString
+// ------------------------------------------------------------------
 var LiteralString;
 (function (LiteralString) {
     function Escape(content) {
@@ -113,6 +133,9 @@ var LiteralString;
     }
     LiteralString.Escape = Escape;
 })(LiteralString || (LiteralString = {}));
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 export class TypeCompilerUnknownTypeError extends Error {
     schema;
     constructor(schema) {
@@ -127,6 +150,9 @@ export class TypeCompilerTypeGuardError extends Error {
         this.schema = schema;
     }
 }
+// ------------------------------------------------------------------
+// Policy
+// ------------------------------------------------------------------
 export var Policy;
 (function (Policy) {
     function IsExactOptionalProperty(value, key, expression) {
@@ -152,11 +178,18 @@ export var Policy;
     }
     Policy.IsVoidLike = IsVoidLike;
 })(Policy || (Policy = {}));
+/** Compiles Types for Runtime Type Checking */
 export var TypeCompiler;
 (function (TypeCompiler) {
+    // ----------------------------------------------------------------
+    // Guards
+    // ----------------------------------------------------------------
     function IsAnyOrUnknown(schema) {
         return schema[Kind] === 'Any' || schema[Kind] === 'Unknown';
     }
+    // ----------------------------------------------------------------
+    // Types
+    // ----------------------------------------------------------------
     function* TAny(schema, references, value) {
         yield 'true';
     }
@@ -338,6 +371,8 @@ export var TypeCompiler;
     }
     function* TRef(schema, references, value) {
         const target = Deref(schema, references);
+        // Reference: If we have seen this reference before we can just yield and return the function call.
+        // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
         if (state.functions.has(schema.$ref))
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
         yield* Visit(target, references, value);
@@ -365,6 +400,7 @@ export var TypeCompiler;
         yield `${variable}.test(${value})`;
     }
     function* TThis(schema, references, value) {
+        // Note: This types are assured to be hoisted prior to this call. Just yield the function.
         yield `${CreateFunctionName(schema.$ref)}(${value})`;
     }
     function* TTuple(schema, references, value) {
@@ -405,6 +441,9 @@ export var TypeCompiler;
     function* Visit(schema, references, value, useHoisting = true) {
         const references_ = IsString(schema.$id) ? [...references, schema] : references;
         const schema_ = schema;
+        // --------------------------------------------------------------
+        // Hoisting
+        // --------------------------------------------------------------
         if (useHoisting && IsString(schema.$id)) {
             const functionName = CreateFunctionName(schema.$id);
             if (state.functions.has(functionName)) {
@@ -483,12 +522,19 @@ export var TypeCompiler;
                 return yield* TKind(schema_, references_, value);
         }
     }
+    // ----------------------------------------------------------------
+    // Compiler State
+    // ----------------------------------------------------------------
+    // prettier-ignore
     const state = {
-        language: 'javascript',
-        functions: new Map(),
-        variables: new Map(),
-        instances: new Map()
+        language: 'javascript', // target language
+        functions: new Map(), // local functions
+        variables: new Map(), // local variables
+        instances: new Map() // exterior kind instances
     };
+    // ----------------------------------------------------------------
+    // Compiler Factory
+    // ----------------------------------------------------------------
     function CreateExpression(schema, references, value, useHoisting = true) {
         return `(${[...Visit(schema, references, value, useHoisting)].join(' && ')})`;
     }
@@ -514,24 +560,31 @@ export var TypeCompiler;
     function CreateReturns(type) {
         return state.language === 'typescript' ? `: ${type}` : '';
     }
+    // ----------------------------------------------------------------
+    // Compile
+    // ----------------------------------------------------------------
     function Build(schema, references, options) {
-        const functionCode = CreateFunction('check', schema, references, 'value');
+        const functionCode = CreateFunction('check', schema, references, 'value'); // will populate functions and variables
         const parameter = CreateParameter('value', 'any');
         const returns = CreateReturns('boolean');
         const functions = [...state.functions.values()];
         const variables = [...state.variables.values()];
-        const checkFunction = IsString(schema.$id)
+        // prettier-ignore
+        const checkFunction = IsString(schema.$id) // ensure top level schemas with $id's are hoisted
             ? `return function check(${parameter})${returns} {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
             : `return ${functionCode}`;
         return [...variables, ...functions, checkFunction].join('\n');
     }
+    /** Generates the code used to assert this type and returns it as a string */
     function Code(...args) {
         const defaults = { language: 'javascript' };
+        // prettier-ignore
         const [schema, references, options] = (args.length === 2 && IsArray(args[1]) ? [args[0], args[1], defaults] :
             args.length === 2 && !IsArray(args[1]) ? [args[0], [], args[1]] :
                 args.length === 3 ? [args[0], args[1], args[2]] :
                     args.length === 1 ? [args[0], [], defaults] :
                         [null, [], defaults]);
+        // compiler-reset
         state.language = options.language;
         state.variables.clear();
         state.functions.clear();
@@ -544,6 +597,7 @@ export var TypeCompiler;
         return Build(schema, references, options);
     }
     TypeCompiler.Code = Code;
+    /** Compiles a TypeBox type for optimal runtime type checking. Types must be valid TypeBox types of TSchema */
     function Compile(schema, references = []) {
         const generatedCode = Code(schema, references, { language: 'javascript' });
         const compiledFunction = globalThis.Function('kind', 'format', 'hash', generatedCode);

package/build/import/errors/errors.d.mts

@@ -79,7 +79,10 @@ export declare class ValueErrorIterator {
     private readonly iterator;
     constructor(iterator: IterableIterator<ValueError>);
     [Symbol.iterator](): IterableIterator<ValueError>;
+    /** Returns the first value error or undefined if no errors */
     First(): ValueError | undefined;
 }
+/** Returns an iterator for each error in this value. */
 export declare function Errors<T extends TSchema>(schema: T, references: TSchema[], value: unknown): ValueErrorIterator;
+/** Returns an iterator for each error in this value. */
 export declare function Errors<T extends TSchema>(schema: T, value: unknown): ValueErrorIterator;

package/build/import/errors/errors.mjs

@@ -8,6 +8,9 @@ import { Deref } from '../value/deref/index.mjs';
 import { Hash } from '../value/hash/index.mjs';
 import { Kind } from '../type/symbols/index.mjs';
 import { Never } from '../type/never/index.mjs';
+// --------------------------------------------------------------------------
+// ValueErrorType
+// --------------------------------------------------------------------------
 export var ValueErrorType;
 (function (ValueErrorType) {
     ValueErrorType[ValueErrorType["ArrayContains"] = 0] = "ArrayContains";
@@ -74,6 +77,9 @@ export var ValueErrorType;
     ValueErrorType[ValueErrorType["Union"] = 61] = "Union";
     ValueErrorType[ValueErrorType["Void"] = 62] = "Void";
 })(ValueErrorType || (ValueErrorType = {}));
+// --------------------------------------------------------------------------
+// ValueErrors
+// --------------------------------------------------------------------------
 export class ValueErrorsUnknownTypeError extends Error {
     schema;
     constructor(schema) {
@@ -81,12 +87,21 @@ export class ValueErrorsUnknownTypeError extends Error {
         this.schema = schema;
     }
 }
+// --------------------------------------------------------------------------
+// EscapeKey
+// --------------------------------------------------------------------------
 function EscapeKey(key) {
-    return key.replace(/~/g, '~0').replace(/\//g, '~1');
+    return key.replace(/~/g, '~0').replace(/\//g, '~1'); // RFC6901 Path
 }
+// --------------------------------------------------------------------------
+// Guards
+// --------------------------------------------------------------------------
 function IsDefined(value) {
     return value !== undefined;
 }
+// --------------------------------------------------------------------------
+// ValueErrorIterator
+// --------------------------------------------------------------------------
 export class ValueErrorIterator {
     iterator;
     constructor(iterator) {
@@ -95,14 +110,21 @@ export class ValueErrorIterator {
     [Symbol.iterator]() {
         return this.iterator;
     }
+    /** Returns the first value error or undefined if no errors */
     First() {
         const next = this.iterator.next();
         return next.done ? undefined : next.value;
     }
 }
+// --------------------------------------------------------------------------
+// Create
+// --------------------------------------------------------------------------
 function Create(type, schema, path, value) {
     return { type, schema, path, value, message: GetErrorFunction()(schema, type) };
 }
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
 function* TAny(schema, references, path, value) { }
 function* TArray(schema, references, path, value) {
     if (!IsArray(value)) {
@@ -117,6 +139,7 @@ function* TArray(schema, references, path, value) {
     for (let i = 0; i < value.length; i++) {
         yield* Visit(schema.items, references, `${path}/${i}`, value[i]);
     }
+    // prettier-ignore
     if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
         const hashed = Hash(element);
         if (set.has(hashed)) {
@@ -128,6 +151,7 @@ function* TArray(schema, references, path, value) {
     } return true; })())) {
         yield Create(ValueErrorType.ArrayUniqueItems, schema, path, value);
     }
+    // contains
     if (!(IsDefined(schema.contains) || IsDefined(schema.minContains) || IsDefined(schema.maxContains))) {
         return;
     }
@@ -237,7 +261,7 @@ function* TIntersect(schema, references, path, value) {
             if (!keyCheck.test(valueKey)) {
                 const next = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next();
                 if (!next.done)
-                    yield next.value;
+                    yield next.value; // yield interior
             }
         }
     }
@@ -429,7 +453,7 @@ function* TUnion(schema, references, path, value) {
     for (const subschema of schema.anyOf) {
         const errors = [...Visit(subschema, references, path, value)];
         if (errors.length === 0)
-            return;
+            return; // matched
         count += errors.length;
     }
     if (count > 0) {
@@ -526,6 +550,7 @@ function* Visit(schema, references, path, value) {
             return yield* TKind(schema_, references_, path, value);
     }
 }
+/** Returns an iterator for each error in this value. */
 export function Errors(...args) {
     const iterator = args.length === 3 ? Visit(args[0], args[1], '', args[2]) : Visit(args[0], [], '', args[1]);
     return new ValueErrorIterator(iterator);

package/build/import/errors/function.d.mts

@@ -1,6 +1,9 @@
 import { TSchema } from '../type/schema/index.mjs';
 import { ValueErrorType } from './errors.mjs';
+/** Creates an error message using en-US as the default locale */
 export declare function DefaultErrorFunction(schema: TSchema, errorType: ValueErrorType): string;
 export type ErrorFunction = (schema: TSchema, type: ValueErrorType) => string;
+/** Sets the error function used to generate error messages */
 export declare function SetErrorFunction(callback: ErrorFunction): void;
+/** Gets the error function used to generate error messages */
 export declare function GetErrorFunction(): ErrorFunction;

package/build/import/errors/function.mjs

@@ -1,5 +1,6 @@
 import { Kind } from '../type/symbols/index.mjs';
 import { ValueErrorType } from './errors.mjs';
+/** Creates an error message using en-US as the default locale */
 export function DefaultErrorFunction(schema, errorType) {
     switch (errorType) {
         case ValueErrorType.ArrayContains:
@@ -132,10 +133,13 @@ export function DefaultErrorFunction(schema, errorType) {
             return 'Unknown error type';
     }
 }
+/** Manages error message providers */
 let errorFunction = DefaultErrorFunction;
+/** Sets the error function used to generate error messages */
 export function SetErrorFunction(callback) {
     errorFunction = callback;
 }
+/** Gets the error function used to generate error messages */
 export function GetErrorFunction() {
     return errorFunction;
 }

package/build/import/index.mjs

@@ -1,8 +1,14 @@
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
 export { Kind, Hint, ReadonlyKind, OptionalKind, TransformKind } from './type/symbols/index.mjs';
 export { PatternBoolean, PatternBooleanExact, PatternNumber, PatternNumberExact, PatternString, PatternStringExact } from './type/patterns/index.mjs';
 export { TypeRegistry, FormatRegistry } from './type/registry/index.mjs';
 export { TypeGuard, ValueGuard } from './type/guard/index.mjs';
 export { CloneType, CloneRest } from './type/clone/type.mjs';
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
 export { Any } from './type/any/index.mjs';
 export { Array } from './type/array/index.mjs';
 export { AsyncIterator } from './type/async-iterator/index.mjs';
@@ -62,4 +68,7 @@ export { Union, UnionEvaluated } from './type/union/index.mjs';
 export { Unknown } from './type/unknown/index.mjs';
 export { Unsafe } from './type/unsafe/index.mjs';
 export { Void } from './type/void/index.mjs';
+// ------------------------------------------------------------------
+// Namespace
+// ------------------------------------------------------------------
 export { Type, JsonTypeBuilder, JavaScriptTypeBuilder } from './type/type/index.mjs';

package/build/import/system/policy.d.mts

@@ -1,11 +1,21 @@
 export declare namespace TypeSystemPolicy {
+    /** Shared assertion routines used by the value and errors modules */
+    /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
     let ExactOptionalPropertyTypes: boolean;
+    /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
     let AllowArrayObject: boolean;
+    /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
     let AllowNaN: boolean;
+    /** Sets whether `null` should validate for void types. The default is `false` */
     let AllowNullVoid: boolean;
+    /** Asserts this value using the ExactOptionalPropertyTypes policy */
     function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string): boolean;
+    /** Asserts this value using the AllowArrayObjects policy */
     function IsObjectLike(value: unknown): value is Record<keyof any, unknown>;
+    /** Asserts this value as a record using the AllowArrayObjects policy */
     function IsRecordLike(value: unknown): value is Record<keyof any, unknown>;
+    /** Asserts this value using the AllowNaN policy */
     function IsNumberLike(value: unknown): value is number;
+    /** Asserts this value using the AllowVoidNull policy */
     function IsVoidLike(value: unknown): value is void;
 }

package/build/import/system/policy.mjs

@@ -1,28 +1,41 @@
 import { IsObject, IsArray, IsNumber, IsUndefined } from '../value/guard/index.mjs';
 export var TypeSystemPolicy;
 (function (TypeSystemPolicy) {
+    // ------------------------------------------------------------------
+    // TypeSystemPolicy
+    // ------------------------------------------------------------------
+    /** Shared assertion routines used by the value and errors modules */
+    /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
     TypeSystemPolicy.ExactOptionalPropertyTypes = false;
+    /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
     TypeSystemPolicy.AllowArrayObject = false;
+    /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
     TypeSystemPolicy.AllowNaN = false;
+    /** Sets whether `null` should validate for void types. The default is `false` */
     TypeSystemPolicy.AllowNullVoid = false;
+    /** Asserts this value using the ExactOptionalPropertyTypes policy */
     function IsExactOptionalProperty(value, key) {
         return TypeSystemPolicy.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
     }
     TypeSystemPolicy.IsExactOptionalProperty = IsExactOptionalProperty;
+    /** Asserts this value using the AllowArrayObjects policy */
     function IsObjectLike(value) {
         const isObject = IsObject(value);
         return TypeSystemPolicy.AllowArrayObject ? isObject : isObject && !IsArray(value);
     }
     TypeSystemPolicy.IsObjectLike = IsObjectLike;
+    /** Asserts this value as a record using the AllowArrayObjects policy */
     function IsRecordLike(value) {
         return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
     }
     TypeSystemPolicy.IsRecordLike = IsRecordLike;
+    /** Asserts this value using the AllowNaN policy */
     function IsNumberLike(value) {
         const isNumber = IsNumber(value);
         return TypeSystemPolicy.AllowNaN ? isNumber : isNumber && Number.isFinite(value);
     }
     TypeSystemPolicy.IsNumberLike = IsNumberLike;
+    /** Asserts this value using the AllowVoidNull policy */
     function IsVoidLike(value) {
         const isUndefined = IsUndefined(value);
         return TypeSystemPolicy.AllowNullVoid ? isUndefined || value === null : isUndefined;

package/build/import/system/system.d.mts

@@ -4,7 +4,10 @@ export declare class TypeSystemDuplicateTypeKind extends Error {
 export declare class TypeSystemDuplicateFormat extends Error {
     constructor(kind: string);
 }
+/** Creates user defined types and formats and provides overrides for value checking behaviours */
 export declare namespace TypeSystem {
+    /** Creates a new type */
     function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => import("../type/unsafe/unsafe.mjs").TUnsafe<Type>;
+    /** Creates a new string format */
     function Format<F extends string>(format: F, check: (value: string) => boolean): F;
 }

package/build/import/system/system.mjs

@@ -1,6 +1,9 @@
 import { TypeRegistry, FormatRegistry } from '../type/registry/index.mjs';
 import { Unsafe } from '../type/unsafe/index.mjs';
 import { Kind } from '../type/symbols/index.mjs';
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 export class TypeSystemDuplicateTypeKind extends Error {
     constructor(kind) {
         super(`Duplicate type kind '${kind}' detected`);
@@ -11,8 +14,13 @@ export class TypeSystemDuplicateFormat extends Error {
         super(`Duplicate string format '${kind}' detected`);
     }
 }
+// ------------------------------------------------------------------
+// TypeSystem
+// ------------------------------------------------------------------
+/** Creates user defined types and formats and provides overrides for value checking behaviours */
 export var TypeSystem;
 (function (TypeSystem) {
+    /** Creates a new type */
     function Type(kind, check) {
         if (TypeRegistry.Has(kind))
             throw new TypeSystemDuplicateTypeKind(kind);
@@ -20,6 +28,7 @@ export var TypeSystem;
         return (options = {}) => Unsafe({ ...options, [Kind]: kind });
     }
     TypeSystem.Type = Type;
+    /** Creates a new string format */
     function Format(format, check) {
         if (FormatRegistry.Has(format))
             throw new TypeSystemDuplicateFormat(format);

package/build/import/type/any/any.d.mts

@@ -4,4 +4,5 @@ export interface TAny extends TSchema {
     [Kind]: 'Any';
     static: any;
 }
+/** `[Json]` Creates an Any type */
 export declare function Any(options?: SchemaOptions): TAny;

package/build/import/type/any/any.mjs

@@ -1,4 +1,5 @@
 import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates an Any type */
 export function Any(options = {}) {
     return { ...options, [Kind]: 'Any' };
 }

package/build/import/type/array/array.d.mts

@@ -2,11 +2,17 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Static } from '../static/index.mjs';
 import { Kind } from '../symbols/index.mjs';
 export interface ArrayOptions extends SchemaOptions {
+    /** The minimum number of items in this array */
     minItems?: number;
+    /** The maximum number of items in this array */
     maxItems?: number;
+    /** Should this schema contain unique items */
     uniqueItems?: boolean;
+    /** A schema for which some elements should match */
     contains?: TSchema;
+    /** A minimum number of contains schema matches */
     minContains?: number;
+    /** A maximum number of contains schema matches */
     maxContains?: number;
 }
 export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
@@ -15,4 +21,5 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
     type: 'array';
     items: T;
 }
+/** `[Json]` Creates an Array type */
 export declare function Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;

package/build/import/type/array/array.mjs

@@ -1,5 +1,6 @@
 import { Kind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
+/** `[Json]` Creates an Array type */
 export function Array(schema, options = {}) {
     return {
         ...options,

package/build/import/type/async-iterator/async-iterator.d.mts

@@ -7,4 +7,5 @@ export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
     type: 'AsyncIterator';
     items: T;
 }
+/** `[JavaScript]` Creates a AsyncIterator type */
 export declare function AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;

package/build/import/type/async-iterator/async-iterator.mjs

@@ -1,5 +1,6 @@
 import { Kind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
+/** `[JavaScript]` Creates a AsyncIterator type */
 export function AsyncIterator(items, options = {}) {
     return {
         ...options,

package/build/import/type/awaited/awaited.d.mts

@@ -2,10 +2,11 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TPromise } from '../promise/index.mjs';
-type AwaitedUnwrap<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [AwaitedResolve<L>, ...AwaitedUnwrap<R>] : [];
-declare function AwaitedUnwrap<T extends TSchema[]>(T: [...T]): AwaitedUnwrap<T>;
-export type AwaitedResolve<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<AwaitedUnwrap<S>> : T extends TUnion<infer S> ? TUnion<AwaitedUnwrap<S>> : T extends TPromise<infer S> ? AwaitedResolve<S> : T;
-export declare function Resolve<T extends TSchema>(T: T): AwaitedResolve<T>;
-export type TAwaited<T extends TSchema> = AwaitedResolve<T>;
-export declare function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): AwaitedResolve<T>;
+type FromRest<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromSchema<L>, ...FromRest<R>] : [];
+declare function FromRest<T extends TSchema[]>(T: [...T]): FromRest<T>;
+type FromSchema<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<FromRest<S>> : T extends TUnion<infer S> ? TUnion<FromRest<S>> : T extends TPromise<infer S> ? FromSchema<S> : T;
+declare function FromSchema<T extends TSchema>(T: T): FromSchema<T>;
+export type TAwaited<T extends TSchema> = (FromSchema<T>);
+/** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+export declare function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): FromSchema<T>;
 export {};

package/build/import/type/awaited/awaited.mjs

@@ -1,28 +1,38 @@
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { CloneType } from '../clone/type.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TIntersect as IsIntersectType, TUnion as IsUnionType, TPromise as IsPromiseType } from '../guard/type.mjs';
-function AwaitedUnwrap(T) {
+// prettier-ignore
+function FromRest(T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [Resolve(L), ...AwaitedUnwrap(R)]
+        ? [FromSchema(L), ...FromRest(R)]
         : []);
 }
-function AwaitedIntersectRest(T) {
-    return Intersect(AwaitedUnwrap(T));
+// prettier-ignore
+function FromIntersect(T) {
+    return Intersect(FromRest(T));
 }
-function AwaitedUnionRest(T) {
-    return Union(AwaitedUnwrap(T));
+// prettier-ignore
+function FromUnion(T) {
+    return Union(FromRest(T));
 }
-function AwaitedPromise(T) {
-    return Resolve(T);
+// prettier-ignore
+function FromPromise(T) {
+    return FromSchema(T);
 }
-export function Resolve(T) {
-    return (IsIntersectType(T) ? AwaitedIntersectRest(T.allOf) :
-        IsUnionType(T) ? AwaitedUnionRest(T.anyOf) :
-            IsPromiseType(T) ? AwaitedPromise(T.item) :
+// prettier-ignore
+function FromSchema(T) {
+    return (IsIntersectType(T) ? FromIntersect(T.allOf) :
+        IsUnionType(T) ? FromUnion(T.anyOf) :
+            IsPromiseType(T) ? FromPromise(T.item) :
                 T);
 }
+/** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
 export function Awaited(T, options = {}) {
-    return CloneType(Resolve(T), options);
+    return CloneType(FromSchema(T), options);
 }