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

package/build/require/type/operators/operators.js

@@ -1,6 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperatorUnionMany = exports.OperatorIntersectMany = exports.OperatorComplement = exports.OperatorUnion = exports.OperatorIntersect = exports.OperatorDistinct = exports.OperatorSubset = exports.OperatorIncludes = void 0;
+/** Returns true if element S is in the set of T */
+// prettier-ignore
 function OperatorIncludes(T, S) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -10,6 +13,8 @@ function OperatorIncludes(T, S) {
         : false);
 }
 exports.OperatorIncludes = OperatorIncludes;
+/** Returns true if T is a subset of S */
+// prettier-ignore
 function OperatorSubset(T, S) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -19,6 +24,8 @@ function OperatorSubset(T, S) {
         : true);
 }
 exports.OperatorSubset = OperatorSubset;
+/** Returns a distinct set of elements */
+// prettier-ignore
 function OperatorDistinct(T, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -28,6 +35,8 @@ function OperatorDistinct(T, Acc = []) {
         : Acc);
 }
 exports.OperatorDistinct = OperatorDistinct;
+/** Returns the Intersect of the given sets */
+// prettier-ignore
 function OperatorIntersect(T, S) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -37,6 +46,8 @@ function OperatorIntersect(T, S) {
         : []);
 }
 exports.OperatorIntersect = OperatorIntersect;
+/** Returns the Union of the given sets */
+// prettier-ignore
 function OperatorUnion(T, S) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -46,6 +57,8 @@ function OperatorUnion(T, S) {
         : S);
 }
 exports.OperatorUnion = OperatorUnion;
+/** Returns the Complement by omitting elements in T that are in S */
+// prettier-ignore
 function OperatorComplement(T, S) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -55,6 +68,8 @@ function OperatorComplement(T, S) {
         : []);
 }
 exports.OperatorComplement = OperatorComplement;
+/** Returns the Intersect of multiple sets */
+// prettier-ignore
 function OperatorIntersectMany(T) {
     return (T.length === 1
         ? T[0]
@@ -66,6 +81,7 @@ function OperatorIntersectMany(T) {
         })());
 }
 exports.OperatorIntersectMany = OperatorIntersectMany;
+/** Returns the Union of multiple sets */
 function OperatorUnionMany(T) {
     return (T.length === 1
         ? T[0]

package/build/require/type/optional/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/optional/optional.d.ts

@@ -3,4 +3,5 @@ import { OptionalKind } from '../symbols/index';
 export type TOptional<T extends TSchema> = T & {
     [OptionalKind]: 'Optional';
 };
+/** `[Json]` Creates an Optional property */
 export declare function Optional<T extends TSchema>(schema: T): TOptional<T>;

package/build/require/type/optional/optional.js

@@ -1,8 +1,10 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Optional = void 0;
 const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
+/** `[Json]` Creates an Optional property */
 function Optional(schema) {
     return { ...(0, type_1.CloneType)(schema), [index_1.OptionalKind]: 'Optional' };
 }

package/build/require/type/parameters/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/parameters/parameters.d.ts

@@ -3,4 +3,5 @@ import type { TFunction } from '../function/index';
 import type { Ensure } from '../helpers/index';
 import { type TTuple } from '../tuple/index';
 export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>;
+/** `[JavaScript]` Extracts the Parameters from the given Function type */
 export declare function Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T>;

package/build/require/type/parameters/parameters.js

@@ -1,8 +1,10 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parameters = void 0;
 const index_1 = require("../tuple/index");
 const type_1 = require("../clone/type");
+/** `[JavaScript]` Extracts the Parameters from the given Function type */
 function Parameters(schema, options = {}) {
     return (0, index_1.Tuple)((0, type_1.CloneRest)(schema.parameters), { ...options });
 }

package/build/require/type/partial/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/partial/partial-from-mapped-result.js

@@ -1,16 +1,20 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PartialFromMappedResult = void 0;
 const index_1 = require("../mapped/index");
 const partial_1 = require("./partial");
+// prettier-ignore
 function FromProperties(K, options) {
     return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
         return { ...Acc, [K2]: (0, partial_1.Partial)(K[K2], options) };
     }, {});
 }
+// prettier-ignore
 function FromMappedResult(K, options) {
     return FromProperties(K.properties, options);
 }
+// prettier-ignore
 function PartialFromMappedResult(T, options) {
     const P = FromMappedResult(T, options);
     return (0, index_1.MappedResult)(P);

package/build/require/type/partial/partial.d.ts

@@ -20,6 +20,8 @@ declare function FromProperties<T extends TProperties>(T: T): TProperties;
 type PartialResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<PartialResolve<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 PartialResolve<T extends TSchema>(T: T): PartialResolve<T>;
 export type TPartial<T extends TSchema> = PartialResolve<T>;
+/** `[Json]` Constructs a type where all properties are optional */
 export declare function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>;
+/** `[Json]` Constructs a type where all properties are optional */
 export declare function Partial<T extends TSchema>(T: T, options?: SchemaOptions): TPartial<T>;
 export {};

package/build/require/type/partial/partial.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Partial = void 0;
 const index_1 = require("../optional/index");
@@ -9,30 +10,39 @@ const index_5 = require("../discard/index");
 const index_6 = require("../symbols/index");
 const type_1 = require("../clone/type");
 const partial_from_mapped_result_1 = require("./partial-from-mapped-result");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
+// prettier-ignore
 function FromIntersect(T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [PartialResolve(L), ...FromIntersect(R)]
         : []);
 }
+// prettier-ignore
 function FromUnion(T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [PartialResolve(L), ...FromUnion(R)]
         : []);
 }
+// prettier-ignore
 function FromProperties(T) {
     return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K) => {
         return { ...Acc, [K]: (0, index_1.Optional)(T[K]) };
     }, {});
 }
+// prettier-ignore
 function PartialResolve(T) {
     return ((0, type_2.TIntersect)(T) ? (0, index_3.Intersect)(FromIntersect(T.allOf)) :
         (0, type_2.TUnion)(T) ? (0, index_4.Union)(FromUnion(T.anyOf)) :
             (0, type_2.TObject)(T) ? (0, index_2.Object)(FromProperties(T.properties)) :
                 (0, index_2.Object)({}));
 }
+/** `[Json]` Constructs a type where all properties are optional */
 function Partial(T, options = {}) {
     if ((0, type_2.TMappedResult)(T)) {
         return (0, partial_from_mapped_result_1.PartialFromMappedResult)(T, options);

package/build/require/type/patterns/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/patterns/patterns.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = void 0;
 exports.PatternBoolean = '(true|false)';

package/build/require/type/pick/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/pick/pick-from-mapped-key.js

@@ -1,22 +1,27 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PickFromMappedKey = void 0;
 const index_1 = require("../mapped/index");
 const pick_1 = require("./pick");
+// prettier-ignore
 function FromPropertyKey(T, K, options) {
     return {
         [K]: (0, pick_1.Pick)(T, [K], options)
     };
 }
+// prettier-ignore
 function FromPropertyKeys(T, K, options) {
     const [LK, ...RK] = K;
     return (K.length > 0
         ? { ...FromPropertyKey(T, LK, options), ...FromPropertyKeys(T, RK, options) }
         : {});
 }
+// prettier-ignore
 function FromMappedKey(T, K, options) {
     return FromPropertyKeys(T, K.keys, options);
 }
+// prettier-ignore
 function PickFromMappedKey(T, K, options) {
     const P = FromMappedKey(T, K, options);
     return (0, index_1.MappedResult)(P);

package/build/require/type/pick/pick.d.ts

@@ -16,7 +16,10 @@ declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(
 export type PickResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<PickResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
 export declare function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): PickResolve<T, K>;
 export type TPick<T extends TSchema, K extends PropertyKey[]> = PickResolve<T, K>;
+/** `[Json]` Constructs a type whose keys are picked from the given type */
 export declare function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickFromMappedKey<T, K>;
+/** `[Json]` Constructs a type whose keys are picked from the given type */
 export declare function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+/** `[Json]` Constructs a type whose keys are picked from the given type */
 export declare function Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
 export {};

package/build/require/type/pick/pick.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Pick = exports.PickResolve = void 0;
 const index_1 = require("../intersect/index");
@@ -9,18 +10,25 @@ const index_5 = require("../discard/index");
 const index_6 = require("../symbols/index");
 const type_1 = require("../clone/type");
 const pick_from_mapped_key_1 = require("./pick-from-mapped-key");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
 function FromIntersect(T, K) {
     return T.map((T) => PickResolve(T, K));
 }
+// prettier-ignore
 function FromUnion(T, K) {
     return T.map((T) => PickResolve(T, K));
 }
+// prettier-ignore
 function FromProperties(T, K) {
     return K.reduce((Acc, K) => {
         return K in T ? { ...Acc, [K]: T[K] } : Acc;
     }, {});
 }
+// prettier-ignore
 function PickResolve(T, K) {
     return ((0, type_2.TIntersect)(T) ? (0, index_1.Intersect)(FromIntersect(T.allOf, K)) :
         (0, type_2.TUnion)(T) ? (0, index_2.Union)(FromUnion(T.anyOf, K)) :

package/build/require/type/promise/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/promise/promise.d.ts

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

package/build/require/type/promise/promise.js

@@ -1,8 +1,10 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Promise = void 0;
 const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
+/** `[JavaScript]` Creates a Promise type */
 function Promise(item, options = {}) {
     return {
         ...options,

package/build/require/type/readonly/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/readonly/readonly.d.ts

@@ -3,4 +3,5 @@ import { ReadonlyKind } from '../symbols/index';
 export type TReadonly<T extends TSchema> = T & {
     [ReadonlyKind]: 'Readonly';
 };
+/** `[Json]` Creates a Readonly property */
 export declare function Readonly<T extends TSchema>(schema: T): TReadonly<T>;

package/build/require/type/readonly/readonly.js

@@ -1,8 +1,10 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Readonly = void 0;
 const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
+/** `[Json]` Creates a Readonly property */
 function Readonly(schema) {
     return { ...(0, type_1.CloneType)(schema), [index_1.ReadonlyKind]: 'Readonly' };
 }

package/build/require/type/readonly-optional/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/readonly-optional/readonly-optional.d.ts

@@ -2,4 +2,5 @@ import type { TSchema } from '../schema/index';
 import { type TReadonly } from '../readonly/index';
 import { type TOptional } from '../optional/index';
 export type TReadonlyOptional<T extends TSchema> = TOptional<T> & TReadonly<T>;
+/** `[Json]` Creates a Readonly and Optional property */
 export declare function ReadonlyOptional<T extends TSchema>(schema: T): TReadonly<TOptional<T>>;

package/build/require/type/readonly-optional/readonly-optional.js

@@ -1,8 +1,10 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReadonlyOptional = void 0;
 const index_1 = require("../readonly/index");
 const index_2 = require("../optional/index");
+/** `[Json]` Creates a Readonly and Optional property */
 function ReadonlyOptional(schema) {
     return (0, index_1.Readonly)((0, index_2.Optional)(schema));
 }

package/build/require/type/record/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/record/record.d.ts

@@ -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/require/type/record/record.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Record = void 0;
 const index_1 = require("../object/index");
@@ -10,46 +11,71 @@ const index_6 = require("../indexed/index");
 const index_7 = require("../symbols/index");
 const type_1 = require("../clone/type");
 const value_1 = require("../guard/value");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
-function FromPattern(pattern, T) {
-    return { [index_7.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: (0, type_1.CloneType)(T) } };
+// ------------------------------------------------------------------
+// RecordCreateFromPattern
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordCreateFromPattern(pattern, T, options) {
+    return {
+        ...options,
+        [index_7.Kind]: 'Record',
+        type: 'object',
+        patternProperties: { [pattern]: (0, type_1.CloneType)(T) }
+    };
 }
-function FromKeys(keys, T) {
-    const properties = keys.reduce((acc, key) => ({ ...acc, [key]: (0, type_1.CloneType)(T) }), {});
-    return (0, index_1.Object)(properties, { [index_7.Hint]: 'Record' });
+// ------------------------------------------------------------------
+// RecordCreateFromKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordCreateFromKeys(K, T, options) {
+    const P = K.reduce((Acc, K) => ({ ...Acc, [K]: (0, type_1.CloneType)(T) }), {});
+    return (0, index_1.Object)(P, { ...options, [index_7.Hint]: 'Record' });
 }
-function FromTemplateLiteralKey(K, T) {
+// prettier-ignore
+function FromTemplateLiteralKey(K, T, options) {
     const expression = (0, index_4.TemplateLiteralParseExact)(K.pattern);
     return ((0, index_4.IsTemplateLiteralFinite)(expression)
-        ? FromKeys((0, index_6.IndexPropertyKeys)(K), T)
-        : FromPattern(K.pattern, T));
+        ? RecordCreateFromKeys((0, index_6.IndexPropertyKeys)(K), T, options)
+        : RecordCreateFromPattern(K.pattern, T, options));
 }
-function FromUnionKey(K, T) {
-    return FromKeys((0, index_6.IndexPropertyKeys)((0, index_3.Union)(K)), T);
+// prettier-ignore
+function FromUnionKey(K, T, options) {
+    return RecordCreateFromKeys((0, index_6.IndexPropertyKeys)((0, index_3.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 = (0, value_1.IsUndefined)(K.pattern) ? index_5.PatternStringExact : K.pattern;
-    return FromPattern(pattern, T);
+    return RecordCreateFromPattern(pattern, T, options);
 }
-function FromIntegerKey(_, T) {
-    return FromPattern(index_5.PatternNumberExact, T);
+// prettier-ignore
+function FromIntegerKey(_, T, options) {
+    return RecordCreateFromPattern(index_5.PatternNumberExact, T, options);
 }
-function FromNumberKey(_, T) {
-    return FromPattern(index_5.PatternNumberExact, T);
-}
-function RecordResolve(K, T) {
-    return ((0, type_2.TUnion)(K) ? FromUnionKey(K.anyOf, T) :
-        (0, type_2.TTemplateLiteral)(K) ? FromTemplateLiteralKey(K, T) :
-            (0, type_2.TLiteral)(K) ? FromLiteralKey(K.const, T) :
-                (0, type_2.TString)(K) ? FromStringKey(K, T) :
-                    (0, type_2.TInteger)(K) ? FromIntegerKey(K, T) :
-                        (0, type_2.TNumber)(K) ? FromNumberKey(K, T) :
-                            (0, index_2.Never)());
+// prettier-ignore
+function FromNumberKey(_, T, options) {
+    return RecordCreateFromPattern(index_5.PatternNumberExact, T, options);
 }
+// ------------------------------------------------------------------
+// TRecordOrObject
+// ------------------------------------------------------------------
+/** `[Json]` Creates a Record type */
 function Record(K, T, options = {}) {
-    return (0, type_1.CloneType)(RecordResolve(K, T), options);
+    // prettier-ignore
+    return ((0, type_2.TUnion)(K) ? FromUnionKey(K.anyOf, T, options) :
+        (0, type_2.TTemplateLiteral)(K) ? FromTemplateLiteralKey(K, T, options) :
+            (0, type_2.TLiteral)(K) ? FromLiteralKey(K.const, T, options) :
+                (0, type_2.TString)(K) ? FromStringKey(K, T, options) :
+                    (0, type_2.TInteger)(K) ? FromIntegerKey(K, T, options) :
+                        (0, type_2.TNumber)(K) ? FromNumberKey(K, T, options) :
+                            (0, index_2.Never)(options));
 }
 exports.Record = Record;

package/build/require/type/recursive/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/recursive/recursive.d.ts

@@ -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/require/type/recursive/recursive.js

@@ -1,15 +1,19 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Recursive = void 0;
 const type_1 = require("../clone/type");
 const value_1 = require("../guard/value");
 const index_1 = require("../symbols/index");
+// Auto Tracked For Recursive Types without ID's
 let Ordinal = 0;
+/** `[Json]` Creates a Recursive type */
 function Recursive(callback, options = {}) {
     if ((0, value_1.IsUndefined)(options.$id))
         options.$id = `T${Ordinal++}`;
     const thisType = callback({ [index_1.Kind]: 'This', $ref: `${options.$id}` });
     thisType.$id = options.$id;
+    // prettier-ignore
     return (0, type_1.CloneType)({ ...options, [index_1.Hint]: 'Recursive', ...thisType });
 }
 exports.Recursive = Recursive;

package/build/require/type/ref/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/ref/ref.d.ts

@@ -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/require/type/ref/ref.js

@@ -1,8 +1,10 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ref = void 0;
 const index_1 = require("../symbols/index");
 const value_1 = require("../guard/value");
+/** `[Json]` Creates a Ref type. */
 function Ref(unresolved, options = {}) {
     if ((0, value_1.IsString)(unresolved))
         return { ...options, [index_1.Kind]: 'Ref', $ref: unresolved };

package/build/require/type/regexp/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/regexp/regexp.d.ts

@@ -1,5 +1,7 @@
 import type { SchemaOptions } from '../schema/index';
 import type { TString } from '../string/index';
 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/require/type/regexp/regexp.js

@@ -1,8 +1,10 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegExp = void 0;
 const value_1 = require("../guard/value");
 const index_1 = require("../symbols/index");
+/** `[JavaScript]` Creates a String type */
 function RegExp(unresolved, options = {}) {
     const pattern = (0, value_1.IsString)(unresolved) ? unresolved : unresolved.source;
     return { ...options, [index_1.Kind]: 'String', type: 'string', pattern };