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

package/build/require/type/template-literal/pattern.js

@@ -1,15 +1,27 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralPattern = exports.TemplateLiteralPatternError = void 0;
 const index_1 = require("../patterns/index");
 const index_2 = require("../symbols/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_1 = require("../guard/type");
+// ------------------------------------------------------------------
+// TemplateLiteralPatternError
+// ------------------------------------------------------------------
 class TemplateLiteralPatternError extends Error {
 }
 exports.TemplateLiteralPatternError = TemplateLiteralPatternError;
+// ------------------------------------------------------------------
+// TemplateLiteralPattern
+// ------------------------------------------------------------------
 function Escape(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+// prettier-ignore
 function Visit(schema, acc) {
     return ((0, type_1.TTemplateLiteral)(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
         (0, type_1.TUnion)(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :

package/build/require/type/template-literal/syntax.d.ts

@@ -15,5 +15,6 @@ type FromTerminal<T extends string> = T extends 'boolean' ? TBoolean : T extends
 type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$${infer R}` ? [TLiteral<L>, ...FromString<R>] : T extends `${infer L}` ? [TLiteral<L>] : [
 ];
 export type TemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
+/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
 export declare function TemplateLiteralSyntax(syntax: string): TTemplateLiteralKind[];
 export {};

package/build/require/type/template-literal/syntax.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralSyntax = void 0;
 const index_1 = require("../literal/index");
@@ -8,6 +9,10 @@ const index_4 = require("../number/index");
 const index_5 = require("../string/index");
 const index_6 = require("../union/index");
 const index_7 = require("../never/index");
+// ------------------------------------------------------------------
+// SyntaxParsers
+// ------------------------------------------------------------------
+// prettier-ignore
 function* FromUnion(syntax) {
     const trim = syntax.trim().replace(/"|'/g, '');
     return (trim === 'boolean' ? yield (0, index_2.Boolean)() :
@@ -21,6 +26,7 @@ function* FromUnion(syntax) {
                                 (0, index_6.Union)(literals));
                     })());
 }
+// prettier-ignore
 function* FromTerminal(syntax) {
     if (syntax[1] !== '{') {
         const L = (0, index_1.Literal)('$');
@@ -36,6 +42,7 @@ function* FromTerminal(syntax) {
     }
     yield (0, index_1.Literal)(syntax);
 }
+// prettier-ignore
 function* FromSyntax(syntax) {
     for (let i = 0; i < syntax.length; i++) {
         if (syntax[i] === '$') {
@@ -46,6 +53,8 @@ function* FromSyntax(syntax) {
     }
     yield (0, index_1.Literal)(syntax);
 }
+// prettier-ignore
+/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
 function TemplateLiteralSyntax(syntax) {
     return [...FromSyntax(syntax)];
 }

package/build/require/type/template-literal/template-literal.d.ts

@@ -23,6 +23,8 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
     type: 'string';
     pattern: string;
 }
+/** `[Json]` Creates a TemplateLiteral type from template dsl string */
 export declare function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+/** `[Json]` Creates a TemplateLiteral type */
 export declare function TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
 export {};

package/build/require/type/template-literal/template-literal.js

@@ -1,10 +1,13 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteral = void 0;
 const pattern_1 = require("./pattern");
 const syntax_1 = require("./syntax");
 const value_1 = require("../guard/value");
 const index_1 = require("../symbols/index");
+/** `[Json]` Creates a TemplateLiteral type */
+// prettier-ignore
 function TemplateLiteral(unresolved, options = {}) {
     const pattern = (0, value_1.IsString)(unresolved)
         ? (0, pattern_1.TemplateLiteralPattern)((0, syntax_1.TemplateLiteralSyntax)(unresolved))

package/build/require/type/template-literal/union.d.ts

@@ -3,4 +3,5 @@ import { type TUnion } from '../union/index';
 import { type TLiteral } from '../literal/index';
 import { type TString } from '../string/index';
 import { type TNever } from '../never/index';
+/** Resolves a template literal as a TUnion */
 export declare function TemplateLiteralToUnion(template: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;

package/build/require/type/template-literal/union.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralToUnion = void 0;
 const index_1 = require("../union/index");
@@ -7,6 +8,10 @@ const index_3 = require("../string/index");
 const generate_1 = require("./generate");
 const parser_1 = require("./parser");
 const finite_1 = require("./finite");
+// ------------------------------------------------------------------
+// TemplateLiteralToUnion
+// ------------------------------------------------------------------
+/** Resolves a template literal as a TUnion */
 function TemplateLiteralToUnion(template) {
     const expression = (0, parser_1.TemplateLiteralParseExact)(template.pattern);
     if (!(0, finite_1.IsTemplateLiteralFinite)(expression))

package/build/require/type/transform/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/transform/transform.d.ts

@@ -25,5 +25,6 @@ export interface TTransform<I extends TSchema = TSchema, O extends unknown = unk
     [TransformKind]: TransformOptions<I, O>;
     [key: string]: any;
 }
+/** `[Json]` Creates a Transform type */
 export declare function Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;
 export {};

package/build/require/type/transform/transform.js

@@ -1,9 +1,17 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Transform = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = void 0;
 const type_1 = require("../clone/type");
 const index_1 = require("../symbols/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
+// ------------------------------------------------------------------
+// TransformBuilders
+// ------------------------------------------------------------------
 class TransformDecodeBuilder {
     constructor(schema) {
         this.schema = schema;
@@ -13,6 +21,7 @@ class TransformDecodeBuilder {
     }
 }
 exports.TransformDecodeBuilder = TransformDecodeBuilder;
+// prettier-ignore
 class TransformEncodeBuilder {
     constructor(schema, decode) {
         this.schema = schema;
@@ -34,6 +43,7 @@ class TransformEncodeBuilder {
     }
 }
 exports.TransformEncodeBuilder = TransformEncodeBuilder;
+/** `[Json]` Creates a Transform type */
 function Transform(schema) {
     return new TransformDecodeBuilder(schema);
 }

package/build/require/type/tuple/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/tuple/tuple.d.ts

@@ -12,5 +12,6 @@ export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     minItems: number;
     maxItems: number;
 }
+/** `[Json]` Creates a Tuple type */
 export declare function Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
 export {};

package/build/require/type/tuple/tuple.js

@@ -1,10 +1,14 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tuple = void 0;
 const type_1 = require("../clone/type");
 const index_1 = require("../symbols/index");
+/** `[Json]` Creates a Tuple type */
 function Tuple(items, options = {}) {
+    // return TupleResolver.Resolve(T)
     const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+    // prettier-ignore
     return (items.length > 0 ?
         { ...options, [index_1.Kind]: 'Tuple', type: 'array', items: (0, type_1.CloneRest)(items), additionalItems, minItems, maxItems } :
         { ...options, [index_1.Kind]: 'Tuple', type: 'array', minItems, maxItems });

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

@@ -1,5 +1,6 @@
 export { JsonTypeBuilder } from './json';
 import { JavaScriptTypeBuilder } from './javascript';
+/** JavaScript Type Builder with Static Resolution for TypeScript */
 declare const Type: JavaScriptTypeBuilder;
 export { JavaScriptTypeBuilder };
 export { Type };

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

@@ -1,10 +1,18 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Type = exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = void 0;
+// ------------------------------------------------------------------
+// JsonTypeBuilder
+// ------------------------------------------------------------------
 var json_1 = require("./json");
 Object.defineProperty(exports, "JsonTypeBuilder", { enumerable: true, get: function () { return json_1.JsonTypeBuilder; } });
+// ------------------------------------------------------------------
+// JavaScriptTypeBuilder
+// ------------------------------------------------------------------
 const TypeBuilder = require("./type");
 const javascript_1 = require("./javascript");
 Object.defineProperty(exports, "JavaScriptTypeBuilder", { enumerable: true, get: function () { return javascript_1.JavaScriptTypeBuilder; } });
+/** JavaScript Type Builder with Static Resolution for TypeScript */
 const Type = TypeBuilder;
 exports.Type = Type;

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

@@ -17,23 +17,42 @@ import { type TSymbol } from '../symbol/index';
 import { type TUint8Array, type Uint8ArrayOptions } from '../uint8array/index';
 import { type TUndefined } from '../undefined/index';
 import { type TVoid } from '../void/index';
+/** JavaScript Type Builder with Static Resolution for TypeScript */
 export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
+    /** `[JavaScript]` Creates a AsyncIterator type */
     AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;
+    /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
     Awaited<T extends TSchema>(schema: T, options?: SchemaOptions): TAwaited<T>;
+    /** `[JavaScript]` Creates a BigInt type */
     BigInt(options?: BigIntOptions): TBigInt;
+    /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
     ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
+    /** `[JavaScript]` Creates a Constructor type */
     Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
+    /** `[JavaScript]` Creates a Date type */
     Date(options?: DateOptions): TDate;
+    /** `[JavaScript]` Creates a Function type */
     Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
+    /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
     InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;
+    /** `[JavaScript]` Creates an Iterator type */
     Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T>;
+    /** `[JavaScript]` Extracts the Parameters from the given Function type */
     Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T>;
+    /** `[JavaScript]` Creates a Promise type */
     Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
+    /** `[JavaScript]` Creates a String type from a Regular Expression pattern */
     RegExp(pattern: string, options?: SchemaOptions): TRegExp;
+    /** `[JavaScript]` Creates a String type from a Regular Expression */
     RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;
+    /** `[JavaScript]` Extracts the ReturnType from the given Function type */
     ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
+    /** `[JavaScript]` Creates a Symbol type */
     Symbol(options?: SchemaOptions): TSymbol;
+    /** `[JavaScript]` Creates a Undefined type */
     Undefined(options?: SchemaOptions): TUndefined;
+    /** `[JavaScript]` Creates a Uint8Array type */
     Uint8Array(options?: Uint8ArrayOptions): TUint8Array;
+    /** `[JavaScript]` Creates a Void type */
     Void(options?: SchemaOptions): TVoid;
 }

package/build/require/type/type/javascript.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JavaScriptTypeBuilder = void 0;
 const json_1 = require("./json");
@@ -19,55 +20,73 @@ const index_14 = require("../symbol/index");
 const index_15 = require("../uint8array/index");
 const index_16 = require("../undefined/index");
 const index_17 = require("../void/index");
+/** JavaScript Type Builder with Static Resolution for TypeScript */
 class JavaScriptTypeBuilder extends json_1.JsonTypeBuilder {
+    /** `[JavaScript]` Creates a AsyncIterator type */
     AsyncIterator(items, options = {}) {
         return (0, index_1.AsyncIterator)(items, options);
     }
+    /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
     Awaited(schema, options = {}) {
         return (0, index_2.Awaited)(schema, options);
     }
+    /** `[JavaScript]` Creates a BigInt type */
     BigInt(options = {}) {
         return (0, index_3.BigInt)(options);
     }
+    /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
     ConstructorParameters(schema, options = {}) {
         return (0, index_5.ConstructorParameters)(schema, options);
     }
+    /** `[JavaScript]` Creates a Constructor type */
     Constructor(parameters, returns, options) {
         return (0, index_4.Constructor)(parameters, returns, options);
     }
+    /** `[JavaScript]` Creates a Date type */
     Date(options = {}) {
         return (0, index_6.Date)(options);
     }
+    /** `[JavaScript]` Creates a Function type */
     Function(parameters, returns, options) {
         return (0, index_7.Function)(parameters, returns, options);
     }
+    /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
     InstanceType(schema, options = {}) {
         return (0, index_8.InstanceType)(schema, options);
     }
+    /** `[JavaScript]` Creates an Iterator type */
     Iterator(items, options = {}) {
         return (0, index_9.Iterator)(items, options);
     }
+    /** `[JavaScript]` Extracts the Parameters from the given Function type */
     Parameters(schema, options = {}) {
         return (0, index_10.Parameters)(schema, options);
     }
+    /** `[JavaScript]` Creates a Promise type */
     Promise(item, options = {}) {
         return (0, index_11.Promise)(item, options);
     }
+    /** `[JavaScript]` Creates a String type */
     RegExp(unresolved, options = {}) {
         return (0, index_12.RegExp)(unresolved, options);
     }
+    /** `[JavaScript]` Extracts the ReturnType from the given Function type */
     ReturnType(schema, options = {}) {
         return (0, index_13.ReturnType)(schema, options);
     }
+    /** `[JavaScript]` Creates a Symbol type */
     Symbol(options) {
         return (0, index_14.Symbol)(options);
     }
+    /** `[JavaScript]` Creates a Undefined type */
     Undefined(options = {}) {
         return (0, index_16.Undefined)(options);
     }
+    /** `[JavaScript]` Creates a Uint8Array type */
     Uint8Array(options = {}) {
         return (0, index_15.Uint8Array)(options);
     }
+    /** `[JavaScript]` Creates a Void type */
     Void(options = {}) {
         return (0, index_17.Void)(options);
     }

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

@@ -27,7 +27,7 @@ import { type TPartial, type TPartialFromMappedResult } from '../partial/index';
 import { type TPick, type TPickFromMappedKey } from '../pick/index';
 import { type TReadonly } from '../readonly/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
-import { type RecordResolve } from '../record/index';
+import { type TRecordOrObject } from '../record/index';
 import { type TRecursive, type TThis } from '../recursive/index';
 import { type TRef } from '../ref/index';
 import { type TRequired, type TRequiredFromMappedResult } from '../required/index';
@@ -40,65 +40,126 @@ import { type TTuple } from '../tuple/index';
 import { Union } from '../union/index';
 import { type TUnknown } from '../unknown/index';
 import { type TUnsafe, type UnsafeOptions } from '../unsafe/index';
+/** Json Type Builder with Static Resolution for TypeScript */
 export declare class JsonTypeBuilder {
+    /** `[Json]` Omits compositing symbols from this schema */
     Strict<T extends TSchema>(schema: T): T;
+    /** `[Json]` Creates a Readonly and Optional property */
     ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T>;
+    /** `[Json]` Creates a Readonly property */
     Readonly<T extends TSchema>(schema: T): TReadonly<T>;
+    /** `[Json]` Creates an Optional property */
     Optional<T extends TSchema>(schema: T): TOptional<T>;
+    /** `[Json]` Creates an Any type */
     Any(options?: SchemaOptions): TAny;
+    /** `[Json]` Creates an Array type */
     Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;
+    /** `[Json]` Creates a Boolean type */
     Boolean(options?: SchemaOptions): TBoolean;
+    /** `[Json]` Intrinsic function to Capitalize LiteralString types */
     Capitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TCapitalize<T>;
+    /** `[Json]` Creates a Composite object type */
     Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T>;
-    Const<T>(value: T, options?: SchemaOptions): TConst<T>;
+    /** `[JavaScript]` Creates a readonly const type from the given value. */
+    Const</* const (not supported in 4.0) */ T>(value: T, options?: SchemaOptions): TConst<T>;
+    /** `[Json]` Creates a dereferenced type */
     Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
+    /** `[Json]` Creates a Enum type */
     Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;
+    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
     Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
+    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
     Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
+    /** `[Json]` Creates a Conditional type */
     Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>;
+    /** `[Json]` Creates a Conditional type */
     Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedKey<L, R, T, F>;
+    /** `[Json]` Creates a Conditional type */
     Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
+    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
+    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;
+    /** `[Json]` Creates an Integer type */
     Integer(options?: IntegerOptions): TInteger;
+    /** `[Json]` Creates an Intersect type */
     Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T>;
+    /** `[Json]` Creates a KeyOf type */
     KeyOf<T extends TMappedResult>(schema: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
+    /** `[Json]` Creates a KeyOf type */
     KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
+    /** `[Json]` Creates a Literal type */
     Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
+    /** `[Json]` Intrinsic function to Lowercase LiteralString types */
     Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TLowercase<T>;
+    /** `[Json]` Creates a Mapped object type */
     Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R;
+    /** `[Json]` Creates a Mapped object type */
     Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R;
+    /** `[Json]` Creates a Never type */
     Never(options?: SchemaOptions): TNever;
+    /** `[Json]` Creates a Not type */
     Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T>;
+    /** `[Json]` Creates a Null type */
     Null(options?: SchemaOptions): TNull;
+    /** `[Json]` Creates a Number type */
     Number(options?: NumberOptions): TNumber;
+    /** `[Json]` Creates an Object type */
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitFromMappedKey<T, K>;
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
+    /** `[Json]` Constructs a type where all properties are optional */
     Partial<T extends TMappedResult>(T: T, options?: ObjectOptions): TPartialFromMappedResult<T>;
+    /** `[Json]` Constructs a type where all properties are optional */
     Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
     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 */
     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 */
     Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
-    Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordResolve<K, T>;
+    /** `[Json]` Creates a Record type */
+    Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecordOrObject<K, T>;
+    /** `[Json]` Creates a Recursive type */
     Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
+    /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
     Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
+    /** `[Json]` Creates a Ref type. */
     Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
+    /** `[Json]` Constructs a type where all properties are required */
     Required<T extends TMappedResult>(T: T, options?: ObjectOptions): TRequiredFromMappedResult<T>;
+    /** `[Json]` Constructs a type where all properties are required */
     Required<T extends TSchema>(schema: T, options?: ObjectOptions): TRequired<T>;
+    /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
     Rest<T extends TSchema>(schema: T): TRest<T>;
+    /** `[Json]` Creates a String type */
     String(options?: StringOptions): TString;
+    /** `[Json]` Creates a TemplateLiteral type from template dsl string */
     TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+    /** `[Json]` Creates a TemplateLiteral type */
     TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
+    /** `[Json]` Creates a Transform type */
     Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;
+    /** `[Json]` Creates a Tuple type */
     Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
+    /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
     Uncapitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TUncapitalize<T>;
+    /** `[Json]` Creates a Union type */
     Union<T extends TSchema[]>(schemas: [...T], options?: SchemaOptions): Union<T>;
+    /** `[Json]` Creates an Unknown type */
     Unknown(options?: SchemaOptions): TUnknown;
+    /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
     Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
+    /** `[Json]` Intrinsic function to Uppercase LiteralString types */
     Uppercase<T extends TSchema>(schema: T, options?: SchemaOptions): TUppercase<T>;
 }