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

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

@@ -16,7 +16,7 @@ type FromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema,
     [_ in I]: T;
 }>>>);
 type FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends false ? FromTemplateLiteralKeyInfinite<K, T> : FromTemplateLiteralKeyFinite<K, T>;
-declare function FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema>(K: K, T: T): FromTemplateLiteralKey<K, T>;
+declare function FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema>(K: K, T: T, options: ObjectOptions): FromTemplateLiteralKey<K, T>;
 type FromEnumKey<K extends Record<string, string | number>, T extends TSchema> = Ensure<TObject<{
     [_ in K[keyof K]]: T;
 }>>;
@@ -28,26 +28,28 @@ type FromUnionKeyLiteralNumber<K extends TLiteral<number>, T extends TSchema> =
 };
 type FromUnionKeyRest<K extends TSchema[], T extends TSchema> = K extends [infer L extends TSchema, ...infer R extends TSchema[]] ? (L extends TUnion<infer S> ? FromUnionKeyRest<S, T> & FromUnionKeyRest<R, T> : L extends TLiteral<string> ? FromUnionKeyLiteralString<L, T> & FromUnionKeyRest<R, T> : L extends TLiteral<number> ? FromUnionKeyLiteralNumber<L, T> & FromUnionKeyRest<R, T> : {}) : {};
 type FromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties = FromUnionKeyRest<K, T>> = (Ensure<TObject<P>>);
-declare function FromUnionKey<K extends TSchema[], T extends TSchema>(K: K, T: T): FromUnionKey<K, T>;
+declare function FromUnionKey<K extends TSchema[], T extends TSchema>(K: K, T: T, options: ObjectOptions): FromUnionKey<K, T>;
 type FromLiteralKey<K extends TLiteralValue, T extends TSchema> = (Ensure<TObject<{
     [_ in Assert<K, PropertyKey>]: T;
 }>>);
-declare function FromLiteralKey<K extends TLiteralValue, T extends TSchema>(K: K, T: T): FromLiteralKey<K, T>;
+declare function FromLiteralKey<K extends TLiteralValue, T extends TSchema>(K: K, T: T, options: ObjectOptions): FromLiteralKey<K, T>;
 type FromStringKey<_ extends TString, T extends TSchema> = (Ensure<TRecord<TString, T>>);
-declare function FromStringKey<K extends TString, T extends TSchema>(K: K, T: T): FromStringKey<K, T>;
+declare function FromStringKey<K extends TString, T extends TSchema>(K: K, T: T, options: ObjectOptions): FromStringKey<K, T>;
 type FromIntegerKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
-declare function FromIntegerKey<K extends TInteger, T extends TSchema>(_: K, T: T): FromIntegerKey<K, T>;
+declare function FromIntegerKey<K extends TInteger, T extends TSchema>(_: K, T: T, options: ObjectOptions): FromIntegerKey<K, T>;
 type FromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
-declare function FromNumberKey<K extends TNumber, T extends TSchema>(_: K, T: T): FromIntegerKey<K, T>;
-export type RecordResolve<K extends TSchema, T extends TSchema> = K extends TEnum<infer S> ? FromEnumKey<S, T> : K extends TUnion<infer S> ? FromUnionKey<S, T> : K extends TTemplateLiteral ? FromTemplateLiteralKey<K, T> : K extends TLiteral<infer S> ? FromLiteralKey<S, T> : K extends TInteger ? FromIntegerKey<K, T> : K extends TNumber ? FromNumberKey<K, T> : K extends TString ? FromStringKey<K, T> : TNever;
+declare function FromNumberKey<K extends TNumber, T extends TSchema>(_: K, T: T, options: ObjectOptions): FromIntegerKey<K, T>;
+type RecordStatic<K extends TSchema, T extends TSchema, P extends unknown[]> = (Record<Assert<Static<K>, PropertyKey>, Static<T, P>>);
 export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Record';
-    static: Record<Assert<Static<K>, string | number>, Static<T, this['params']>>;
+    static: RecordStatic<K, T, this['params']>;
     type: 'object';
     patternProperties: {
         [pattern: string]: T;
     };
     additionalProperties: TAdditionalProperties;
 }
-export declare function Record<K extends TSchema, T extends TSchema>(K: K, T: T, options?: ObjectOptions): RecordResolve<K, T>;
+export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? FromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? FromEnumKey<S, T> : K extends TUnion<infer S> ? FromUnionKey<S, T> : K extends TLiteral<infer S> ? FromLiteralKey<S, T> : K extends TInteger ? FromIntegerKey<K, T> : K extends TNumber ? FromNumberKey<K, T> : K extends TString ? FromStringKey<K, T> : TNever;
+/** `[Json]` Creates a Record type */
+export declare function Record<K extends TSchema, T extends TSchema>(K: K, T: T, options?: ObjectOptions): TRecordOrObject<K, T>;
 export {};

package/build/import/type/record/record.mjs

@@ -7,45 +7,70 @@ import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { IsUndefined } from '../guard/value.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TInteger as IsIntegerType, TLiteral as IsLiteralType, TNumber as IsNumberType, TString as IsStringType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, } from '../guard/type.mjs';
-function FromPattern(pattern, T) {
-    return { [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: CloneType(T) } };
+// ------------------------------------------------------------------
+// RecordCreateFromPattern
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordCreateFromPattern(pattern, T, options) {
+    return {
+        ...options,
+        [Kind]: 'Record',
+        type: 'object',
+        patternProperties: { [pattern]: CloneType(T) }
+    };
 }
-function FromKeys(keys, T) {
-    const properties = keys.reduce((acc, key) => ({ ...acc, [key]: CloneType(T) }), {});
-    return Object(properties, { [Hint]: 'Record' });
+// ------------------------------------------------------------------
+// RecordCreateFromKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordCreateFromKeys(K, T, options) {
+    const P = K.reduce((Acc, K) => ({ ...Acc, [K]: CloneType(T) }), {});
+    return Object(P, { ...options, [Hint]: 'Record' });
 }
-function FromTemplateLiteralKey(K, T) {
+// prettier-ignore
+function FromTemplateLiteralKey(K, T, options) {
     const expression = TemplateLiteralParseExact(K.pattern);
     return (IsTemplateLiteralFinite(expression)
-        ? FromKeys(IndexPropertyKeys(K), T)
-        : FromPattern(K.pattern, T));
+        ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options)
+        : RecordCreateFromPattern(K.pattern, T, options));
 }
-function FromUnionKey(K, T) {
-    return FromKeys(IndexPropertyKeys(Union(K)), T);
+// prettier-ignore
+function FromUnionKey(K, T, options) {
+    return RecordCreateFromKeys(IndexPropertyKeys(Union(K)), T, options);
 }
-function FromLiteralKey(K, T) {
-    return FromKeys([K.toString()], T);
+// prettier-ignore
+function FromLiteralKey(K, T, options) {
+    return RecordCreateFromKeys([K.toString()], T, options);
 }
-function FromStringKey(K, T) {
+// prettier-ignore
+function FromStringKey(K, T, options) {
     const pattern = IsUndefined(K.pattern) ? PatternStringExact : K.pattern;
-    return FromPattern(pattern, T);
+    return RecordCreateFromPattern(pattern, T, options);
 }
-function FromIntegerKey(_, T) {
-    return FromPattern(PatternNumberExact, T);
+// prettier-ignore
+function FromIntegerKey(_, T, options) {
+    return RecordCreateFromPattern(PatternNumberExact, T, options);
 }
-function FromNumberKey(_, T) {
-    return FromPattern(PatternNumberExact, T);
-}
-function RecordResolve(K, T) {
-    return (IsUnionType(K) ? FromUnionKey(K.anyOf, T) :
-        IsTemplateLiteralType(K) ? FromTemplateLiteralKey(K, T) :
-            IsLiteralType(K) ? FromLiteralKey(K.const, T) :
-                IsStringType(K) ? FromStringKey(K, T) :
-                    IsIntegerType(K) ? FromIntegerKey(K, T) :
-                        IsNumberType(K) ? FromNumberKey(K, T) :
-                            Never());
+// prettier-ignore
+function FromNumberKey(_, T, options) {
+    return RecordCreateFromPattern(PatternNumberExact, T, options);
 }
+// ------------------------------------------------------------------
+// TRecordOrObject
+// ------------------------------------------------------------------
+/** `[Json]` Creates a Record type */
 export function Record(K, T, options = {}) {
-    return CloneType(RecordResolve(K, T), options);
+    // prettier-ignore
+    return (IsUnionType(K) ? FromUnionKey(K.anyOf, T, options) :
+        IsTemplateLiteralType(K) ? FromTemplateLiteralKey(K, T, options) :
+            IsLiteralType(K) ? FromLiteralKey(K.const, T, options) :
+                IsStringType(K) ? FromStringKey(K, T, options) :
+                    IsIntegerType(K) ? FromIntegerKey(K, T, options) :
+                        IsNumberType(K) ? FromNumberKey(K, T, options) :
+                            Never(options));
 }

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

@@ -11,5 +11,6 @@ export interface TRecursive<T extends TSchema> extends TSchema {
     [Hint]: 'Recursive';
     static: RecursiveStatic<T>;
 }
+/** `[Json]` Creates a Recursive type */
 export declare function Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
 export {};

package/build/import/type/recursive/recursive.mjs

@@ -1,11 +1,14 @@
 import { CloneType } from '../clone/type.mjs';
 import { IsUndefined } from '../guard/value.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
+// Auto Tracked For Recursive Types without ID's
 let Ordinal = 0;
+/** `[Json]` Creates a Recursive type */
 export function Recursive(callback, options = {}) {
     if (IsUndefined(options.$id))
         options.$id = `T${Ordinal++}`;
     const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` });
     thisType.$id = options.$id;
+    // prettier-ignore
     return CloneType({ ...options, [Hint]: 'Recursive', ...thisType });
 }

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

@@ -6,5 +6,7 @@ export interface TRef<T extends TSchema = TSchema> extends TSchema {
     static: Static<T, this['params']>;
     $ref: string;
 }
+/** `[Json]` Creates a Ref type. The referenced type must contain a $id */
 export declare function Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
+/** `[Json]` Creates a Ref type. */
 export declare function Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;

package/build/import/type/ref/ref.mjs

@@ -1,5 +1,6 @@
 import { Kind } from '../symbols/index.mjs';
 import { IsString, IsUndefined } from '../guard/value.mjs';
+/** `[Json]` Creates a Ref type. */
 export function Ref(unresolved, options = {}) {
     if (IsString(unresolved))
         return { ...options, [Kind]: 'Ref', $ref: unresolved };

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

@@ -1,5 +1,7 @@
 import type { SchemaOptions } from '../schema/index.mjs';
 import type { TString } from '../string/index.mjs';
 export type TRegExp = TString;
+/** `[JavaScript]` Creates a String type from a Regular Expression pattern */
 export declare function RegExp(pattern: string, options?: SchemaOptions): TRegExp;
+/** `[JavaScript]` Creates a String type from a Regular Expression */
 export declare function RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;

package/build/import/type/regexp/regexp.mjs

@@ -1,5 +1,6 @@
 import { IsString } from '../guard/value.mjs';
 import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a String type */
 export function RegExp(unresolved, options = {}) {
     const pattern = IsString(unresolved) ? unresolved : unresolved.source;
     return { ...options, [Kind]: 'String', type: 'string', pattern };

package/build/import/type/registry/format.d.mts

@@ -1,7 +1,13 @@
 export type FormatRegistryValidationFunction = (value: string) => boolean;
+/** Returns the entries in this registry */
 export declare function Entries(): Map<string, FormatRegistryValidationFunction>;
+/** Clears all user defined string formats */
 export declare function Clear(): void;
+/** Deletes a registered format */
 export declare function Delete(format: string): boolean;
+/** Returns true if the user defined string format exists */
 export declare function Has(format: string): boolean;
+/** Sets a validation function for a user defined string format */
 export declare function Set(format: string, func: FormatRegistryValidationFunction): void;
+/** Gets a validation function for a user defined string format */
 export declare function Get(format: string): FormatRegistryValidationFunction | undefined;

package/build/import/type/registry/format.mjs

@@ -1,19 +1,26 @@
+/** A registry for user defined string formats */
 const map = new Map();
+/** Returns the entries in this registry */
 export function Entries() {
     return new Map(map);
 }
+/** Clears all user defined string formats */
 export function Clear() {
     return map.clear();
 }
+/** Deletes a registered format */
 export function Delete(format) {
     return map.delete(format);
 }
+/** Returns true if the user defined string format exists */
 export function Has(format) {
     return map.has(format);
 }
+/** Sets a validation function for a user defined string format */
 export function Set(format, func) {
     map.set(format, func);
 }
+/** Gets a validation function for a user defined string format */
 export function Get(format) {
     return map.get(format);
 }

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

@@ -1,7 +1,13 @@
 export type TypeRegistryValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean;
+/** Returns the entries in this registry */
 export declare function Entries(): Map<string, TypeRegistryValidationFunction<any>>;
+/** Clears all user defined types */
 export declare function Clear(): void;
+/** Deletes a registered type */
 export declare function Delete(kind: string): boolean;
+/** Returns true if this registry contains this kind */
 export declare function Has(kind: string): boolean;
+/** Sets a validation function for a user defined type */
 export declare function Set<TSchema = unknown>(kind: string, func: TypeRegistryValidationFunction<TSchema>): void;
+/** Gets a custom validation function for a user defined type */
 export declare function Get(kind: string): TypeRegistryValidationFunction<any> | undefined;

package/build/import/type/registry/type.mjs

@@ -1,19 +1,26 @@
+/** A registry for user defined types */
 const map = new Map();
+/** Returns the entries in this registry */
 export function Entries() {
     return new Map(map);
 }
+/** Clears all user defined types */
 export function Clear() {
     return map.clear();
 }
+/** Deletes a registered type */
 export function Delete(kind) {
     return map.delete(kind);
 }
+/** Returns true if this registry contains this kind */
 export function Has(kind) {
     return map.has(kind);
 }
+/** Sets a validation function for a user defined type */
 export function Set(kind, func) {
     map.set(kind, func);
 }
+/** Gets a custom validation function for a user defined type */
 export function Get(kind) {
     return map.get(kind);
 }

package/build/import/type/required/required-from-mapped-result.mjs

@@ -1,13 +1,16 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Required } from './required.mjs';
+// prettier-ignore
 function FromProperties(K, options) {
     return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
         return { ...Acc, [K2]: Required(K[K2], options) };
     }, {});
 }
+// prettier-ignore
 function FromMappedResult(K, options) {
     return FromProperties(K.properties, options);
 }
+// prettier-ignore
 export function RequiredFromMappedResult(T, options) {
     const P = FromMappedResult(T, options);
     return MappedResult(P);

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

@@ -20,6 +20,8 @@ declare function FromProperties<T extends TProperties>(T: T): TProperties;
 type RequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<RequiredResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
 declare function RequiredResolve<T extends TSchema>(T: T): RequiredResolve<T>;
 export type TRequired<T extends TSchema> = RequiredResolve<T>;
+/** `[Json]` Constructs a type where all properties are required */
 export declare function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
+/** `[Json]` Constructs a type where all properties are required */
 export declare function Required<T extends TSchema>(T: T, options?: SchemaOptions): TRequired<T>;
 export {};

package/build/import/type/required/required.mjs

@@ -5,30 +5,39 @@ import { OptionalKind, TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { Discard } from '../discard/index.mjs';
 import { RequiredFromMappedResult } from './required-from-mapped-result.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TMappedResult as IsMappedResultType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType } from '../guard/type.mjs';
+// prettier-ignore
 function FromIntersect(T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [RequiredResolve(L), ...FromIntersect(R)]
         : []);
 }
+// prettier-ignore
 function FromUnion(T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [RequiredResolve(L), ...FromUnion(R)]
         : []);
 }
+// prettier-ignore
 function FromProperties(T) {
     return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K) => {
         return { ...Acc, [K]: Discard(T[K], [OptionalKind]) };
     }, {});
 }
+// prettier-ignore
 function RequiredResolve(T) {
     return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf)) :
         IsUnionType(T) ? Union(FromUnion(T.anyOf)) :
             IsObjectType(T) ? Object(FromProperties(T.properties)) :
                 Object({}));
 }
+/** `[Json]` Constructs a type where all properties are required */
 export function Required(T, options = {}) {
     if (IsMappedResultType(T)) {
         return RequiredFromMappedResult(T, options);

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

@@ -6,4 +6,5 @@ export type RestResolve<T extends TSchema> = T extends TIntersect<infer S> ? [..
 ];
 export declare function RestResolve<T extends TSchema>(T: T): RestResolve<T>;
 export type TRest<T extends TSchema> = RestResolve<T>;
+/** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
 export declare function Rest<T extends TSchema>(T: T): TRest<T>;

package/build/import/type/rest/rest.mjs

@@ -1,8 +1,13 @@
 import { CloneRest } from '../clone/type.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 import { TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType } from '../guard/type.mjs';
 export function RestResolve(T) {
     return (IsIntersectType(T) ? [...T.allOf] : IsUnionType(T) ? [...T.anyOf] : IsTupleType(T) ? [...(T.items ?? [])] : []);
 }
+/** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
 export function Rest(T) {
     return CloneRest(RestResolve(T));
 }

package/build/import/type/return-type/return-type.d.mts

@@ -1,4 +1,5 @@
 import type { SchemaOptions } from '../schema/index.mjs';
 import type { TFunction } from '../function/index.mjs';
 export type TReturnType<T extends TFunction> = T['returns'];
+/** `[JavaScript]` Extracts the ReturnType from the given Function type */
 export declare function ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;

package/build/import/type/return-type/return-type.mjs

@@ -1,4 +1,5 @@
 import { CloneType } from '../clone/type.mjs';
+/** `[JavaScript]` Extracts the ReturnType from the given Function type */
 export function ReturnType(schema, options = {}) {
     return CloneType(schema.returns, options);
 }

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

@@ -1,12 +1,19 @@
 import { Kind, Hint, ReadonlyKind, OptionalKind } from '../symbols/index.mjs';
 export interface SchemaOptions {
     $schema?: string;
+    /** Id for this schema */
     $id?: string;
+    /** Title of this schema */
     title?: string;
+    /** Description of this schema */
     description?: string;
+    /** Default value for this schema */
     default?: any;
+    /** Example values matching this schema */
     examples?: any;
+    /** Optional annotation for readOnly */
     readOnly?: boolean;
+    /** Optional annotation for writeOnly */
     writeOnly?: boolean;
     [prop: string]: any;
 }

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

@@ -24,8 +24,11 @@ export type DecodeProperties<T extends TProperties> = {
 };
 export type DecodeRest<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [DecodeType<L>, ...DecodeRest<R>] : [];
 export type DecodeType<T extends TSchema> = (T extends TOptional<infer S extends TSchema> ? TOptional<DecodeType<S>> : T extends TReadonly<infer S extends TSchema> ? TReadonly<DecodeType<S>> : T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S extends TSchema> ? TArray<DecodeType<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> : T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<DecodeRest<P>, DecodeType<R>> : T extends TEnum<infer S> ? TEnum<S> : T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<DecodeRest<P>, DecodeType<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<DecodeRest<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> : T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> : T extends TObject<infer S> ? TObject<Evaluate<DecodeProperties<S>>> : T extends TPromise<infer S extends TSchema> ? TPromise<DecodeType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, DecodeType<S>> : T extends TRecursive<infer S extends TSchema> ? TRecursive<DecodeType<S>> : T extends TRef<infer S extends TSchema> ? TRef<DecodeType<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<DecodeRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<DecodeRest<S>> : T);
+/** Creates an decoded static type from a TypeBox type */
 export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeType<T>, P>;
+/** Creates an encoded static type from a TypeBox type */
 export type StaticEncode<T extends TSchema, P extends unknown[] = []> = Static<T, P>;
+/** Creates a static type from a TypeBox type */
 export type Static<T extends TSchema, P extends unknown[] = []> = (T & {
     params: P;
 })['static'];

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

@@ -1,2 +1,3 @@
 import type { TSchema } from '../schema/index.mjs';
+/** `[Json]` Omits compositing symbols from this schema */
 export declare function Strict<T extends TSchema>(schema: T): T;

package/build/import/type/strict/strict.mjs

@@ -1,3 +1,4 @@
+/** `[Json]` Omits compositing symbols from this schema */
 export function Strict(schema) {
     return JSON.parse(JSON.stringify(schema));
 }

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

@@ -3,11 +3,17 @@ import { Kind } from '../symbols/index.mjs';
 export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
 export type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
 export interface StringOptions extends SchemaOptions {
+    /** The maximum string length */
     maxLength?: number;
+    /** The minimum string length */
     minLength?: number;
+    /** A regular expression pattern this string should match */
     pattern?: string;
+    /** A format this string should match */
     format?: StringFormatOption;
+    /** The content encoding for this string */
     contentEncoding?: StringContentEncodingOption;
+    /** The content media type for this string */
     contentMediaType?: string;
 }
 export interface TString extends TSchema, StringOptions {
@@ -15,4 +21,5 @@ export interface TString extends TSchema, StringOptions {
     static: string;
     type: 'string';
 }
+/** `[Json]` Creates a String type */
 export declare function String(options?: StringOptions): TString;

package/build/import/type/string/string.mjs

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

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

@@ -6,4 +6,5 @@ export interface TSymbol extends TSchema, SchemaOptions {
     static: symbol;
     type: 'symbol';
 }
+/** `[JavaScript]` Creates a Symbol type */
 export declare function Symbol(options?: SchemaOptions): TSymbol;

package/build/import/type/symbol/symbol.mjs

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

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

@@ -1,5 +1,10 @@
+/** Symbol key applied to transform types */
 export declare const TransformKind: unique symbol;
+/** Symbol key applied to readonly types */
 export declare const ReadonlyKind: unique symbol;
+/** Symbol key applied to optional types */
 export declare const OptionalKind: unique symbol;
+/** Symbol key applied to types */
 export declare const Hint: unique symbol;
+/** Symbol key applied to types */
 export declare const Kind: unique symbol;

package/build/import/type/symbols/symbols.mjs

@@ -1,5 +1,10 @@
+/** Symbol key applied to transform types */
 export const TransformKind = Symbol.for('TypeBox.Transform');
+/** Symbol key applied to readonly types */
 export const ReadonlyKind = Symbol.for('TypeBox.Readonly');
+/** Symbol key applied to optional types */
 export const OptionalKind = Symbol.for('TypeBox.Optional');
+/** Symbol key applied to types */
 export const Hint = Symbol.for('TypeBox.Hint');
+/** Symbol key applied to types */
 export const Kind = Symbol.for('TypeBox.Kind');

package/build/import/type/template-literal/finite.mjs

@@ -1,5 +1,12 @@
+// ------------------------------------------------------------------
+// TemplateLiteralFiniteError
+// ------------------------------------------------------------------
 export class TemplateLiteralFiniteError extends Error {
 }
+// ------------------------------------------------------------------
+// IsTemplateLiteralFiniteCheck
+// ------------------------------------------------------------------
+// prettier-ignore
 function IsNumberExpression(expression) {
     return (expression.type === 'or' &&
         expression.expr.length === 2 &&
@@ -8,6 +15,7 @@ function IsNumberExpression(expression) {
         expression.expr[1].type === 'const' &&
         expression.expr[1].const === '[1-9][0-9]*');
 }
+// prettier-ignore
 function IsBooleanExpression(expression) {
     return (expression.type === 'or' &&
         expression.expr.length === 2 &&
@@ -16,9 +24,11 @@ function IsBooleanExpression(expression) {
         expression.expr[1].type === 'const' &&
         expression.expr[1].const === 'false');
 }
+// prettier-ignore
 function IsStringExpression(expression) {
     return expression.type === 'const' && expression.const === '.*';
 }
+// prettier-ignore
 export function IsTemplateLiteralFinite(expression) {
     return (IsBooleanExpression(expression) ? true :
         IsNumberExpression(expression) || IsStringExpression(expression) ? false :

package/build/import/type/template-literal/generate.mjs

@@ -1,3 +1,7 @@
+// ------------------------------------------------------------------
+// GenerateFromExpression
+// ------------------------------------------------------------------
+// prettier-ignore
 function* GenerateReduce(buffer) {
     if (buffer.length === 1)
         return yield* buffer[0];
@@ -7,16 +11,22 @@ function* GenerateReduce(buffer) {
         }
     }
 }
+// prettier-ignore
 function* GenerateAnd(expression) {
     return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralGenerate(expr)]));
 }
+// prettier-ignore
 function* GenerateOr(expression) {
     for (const expr of expression.expr)
         yield* TemplateLiteralGenerate(expr);
 }
+// prettier-ignore
 function* GenerateConst(expression) {
     return yield expression.const;
 }
+// ------------------------------------------------------------------
+// TemplateLiteralGenerateError
+// ------------------------------------------------------------------
 export class TemplateLiteralGenerateError extends Error {
 }
 export function* TemplateLiteralGenerate(expression) {

package/build/import/type/template-literal/parser.d.mts

@@ -13,5 +13,7 @@ export type ExpressionOr = {
     type: 'or';
     expr: Expression[];
 };
+/** Parses a pattern and returns an expression tree */
 export declare function TemplateLiteralParse(pattern: string): Expression;
+/** Parses a pattern and strips forward and trailing ^ and $ */
 export declare function TemplateLiteralParseExact(pattern: string): Expression;