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

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

@@ -17,6 +17,8 @@ type FromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple
 export type ExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T, U> : T extends TUnion<infer S> ? FromArray<S, U> : T extends U ? T : T);
 export declare function ExtractResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExtractResolve<L, R>;
 export type TExtract<T extends TSchema, U extends TSchema> = ExtractResolve<T, U>;
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
 export declare function 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 */
 export declare function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
 export {};

package/build/require/type/extract/extract.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Extract = exports.ExtractResolve = void 0;
 const index_1 = require("../template-literal/index");
@@ -7,7 +8,9 @@ const index_3 = require("../never/index");
 const index_4 = require("../extends/index");
 const type_1 = require("../clone/type");
 const extract_from_mapped_result_1 = require("./extract-from-mapped-result");
+// prettier-ignore
 const type_2 = require("../guard/type");
+// prettier-ignore
 function ExtractResolve(L, R) {
     return ((0, type_2.TTemplateLiteral)(L) ? ExtractResolve((0, index_1.TemplateLiteralToUnion)(L), R) :
         (0, type_2.TTemplateLiteral)(R) ? ExtractResolve(L, (0, index_1.TemplateLiteralToUnion)(R)) :
@@ -19,6 +22,7 @@ function ExtractResolve(L, R) {
                     (0, index_3.Never)());
 }
 exports.ExtractResolve = ExtractResolve;
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
 function Extract(type, union, options = {}) {
     if ((0, type_2.TMappedResult)(type)) {
         return (0, extract_from_mapped_result_1.ExtractFromMappedResult)(type, union, options);

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

@@ -12,5 +12,6 @@ export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema =
     parameters: T;
     returns: U;
 }
+/** `[JavaScript]` Creates a Function type */
 export declare function Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
 export {};

package/build/require/type/function/function.js

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

package/build/require/type/function/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/guard/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueGuard = exports.TypeGuard = void 0;
 exports.TypeGuard = require("./type");

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

@@ -37,57 +37,103 @@ import type { TDate } from '../date/index';
 import type { TThis } from '../recursive/index';
 export declare class TypeGuardUnknownTypeError extends Error {
 }
+/** Returns true if this value has a Readonly symbol */
 export declare function TReadonly<T extends TSchema>(value: T): value is TReadonly<T>;
+/** Returns true if this value has a Optional symbol */
 export declare function TOptional<T extends TSchema>(value: T): value is TOptional<T>;
+/** Returns true if the given value is TAny */
 export declare function TAny(value: unknown): value is TAny;
+/** Returns true if the given value is TArray */
 export declare function TArray(value: unknown): value is TArray;
+/** Returns true if the given value is TAsyncIterator */
 export declare function TAsyncIterator(value: unknown): value is TAsyncIterator;
+/** Returns true if the given value is TBigInt */
 export declare function TBigInt(value: unknown): value is TBigInt;
+/** Returns true if the given value is TBoolean */
 export declare function TBoolean(value: unknown): value is TBoolean;
+/** Returns true if the given value is TConstructor */
 export declare function TConstructor(value: unknown): value is TConstructor;
+/** Returns true if the given value is TDate */
 export declare function TDate(value: unknown): value is TDate;
+/** Returns true if the given value is TFunction */
 export declare function TFunction(value: unknown): value is TFunction;
+/** Returns true if the given value is TInteger */
 export declare function TInteger(value: unknown): value is TInteger;
+/** Returns true if the given schema is TProperties */
 export declare function TProperties(value: unknown): value is TProperties;
+/** Returns true if the given value is TIntersect */
 export declare function TIntersect(value: unknown): value is TIntersect;
+/** Returns true if the given value is TIterator */
 export declare function TIterator(value: unknown): value is TIterator;
+/** Returns true if the given value is a TKind with the given name. */
 export declare function TKindOf<T extends string>(value: unknown, kind: T): value is Record<PropertyKey, unknown> & {
     [Kind]: T;
 };
+/** Returns true if the given value is TLiteral<string> */
 export declare function TLiteralString(value: unknown): value is TLiteral<string>;
+/** Returns true if the given value is TLiteral<number> */
 export declare function TLiteralNumber(value: unknown): value is TLiteral<number>;
+/** Returns true if the given value is TLiteral<boolean> */
 export declare function TLiteralBoolean(value: unknown): value is TLiteral<boolean>;
+/** Returns true if the given value is TLiteral */
 export declare function TLiteral(value: unknown): value is TLiteral;
+/** Returns true if the given value is a TLiteralValue */
 export declare function TLiteralValue(value: unknown): value is TLiteralValue;
+/** Returns true if the given value is a TMappedKey */
 export declare function TMappedKey(value: unknown): value is TMappedKey;
+/** Returns true if the given value is TMappedResult */
 export declare function TMappedResult(value: unknown): value is TMappedResult;
+/** Returns true if the given value is TNever */
 export declare function TNever(value: unknown): value is TNever;
+/** Returns true if the given value is TNot */
 export declare function TNot(value: unknown): value is TNot;
+/** Returns true if the given value is TNull */
 export declare function TNull(value: unknown): value is TNull;
+/** Returns true if the given value is TNumber */
 export declare function TNumber(value: unknown): value is TNumber;
+/** Returns true if the given value is TObject */
 export declare function TObject(value: unknown): value is TObject;
+/** Returns true if the given value is TPromise */
 export declare function TPromise(value: unknown): value is TPromise;
+/** Returns true if the given value is TRecord */
 export declare function TRecord(value: unknown): value is TRecord;
+/** Returns true if this value is TRecursive */
 export declare function TRecursive(value: unknown): value is {
     [Hint]: 'Recursive';
 };
+/** Returns true if the given value is TRef */
 export declare function TRef(value: unknown): value is TRef;
+/** Returns true if the given value is TString */
 export declare function TString(value: unknown): value is TString;
+/** Returns true if the given value is TSymbol */
 export declare function TSymbol(value: unknown): value is TSymbol;
+/** Returns true if the given value is TTemplateLiteral */
 export declare function TTemplateLiteral(value: unknown): value is TTemplateLiteral<TTemplateLiteralKind[]>;
+/** Returns true if the given value is TThis */
 export declare function TThis(value: unknown): value is TThis;
+/** Returns true of this value is TTransform */
 export declare function TTransform(value: unknown): value is {
     [TransformKind]: TransformOptions;
 };
+/** Returns true if the given value is TTuple */
 export declare function TTuple(value: unknown): value is TTuple;
+/** Returns true if the given value is TUndefined */
 export declare function TUndefined(value: unknown): value is TUndefined;
+/** Returns true if the given value is TUnion<Literal<string | number>[]> */
 export declare function TUnionLiteral(value: unknown): value is TUnion<TLiteral[]>;
+/** Returns true if the given value is TUnion */
 export declare function TUnion(value: unknown): value is TUnion;
+/** Returns true if the given value is TUint8Array */
 export declare function TUint8Array(value: unknown): value is TUint8Array;
+/** Returns true if the given value is TUnknown */
 export declare function TUnknown(value: unknown): value is TUnknown;
+/** Returns true if the given value is a raw TUnsafe */
 export declare function TUnsafe(value: unknown): value is TUnsafe<unknown>;
+/** Returns true if the given value is TVoid */
 export declare function TVoid(value: unknown): value is TVoid;
+/** Returns true if the given value is TKind */
 export declare function TKind(value: unknown): value is Record<PropertyKey, unknown> & {
     [Kind]: string;
 };
+/** Returns true if the given value is TSchema */
 export declare function TSchema(value: unknown): value is TSchema;

package/build/require/type/guard/type.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TSchema = exports.TKind = exports.TVoid = exports.TUnsafe = exports.TUnknown = exports.TUint8Array = exports.TUnion = exports.TUnionLiteral = exports.TUndefined = exports.TTuple = exports.TTransform = exports.TThis = exports.TTemplateLiteral = exports.TSymbol = exports.TString = exports.TRef = exports.TRecursive = exports.TRecord = exports.TPromise = exports.TObject = exports.TNumber = exports.TNull = exports.TNot = exports.TNever = exports.TMappedResult = exports.TMappedKey = exports.TLiteralValue = exports.TLiteral = exports.TLiteralBoolean = exports.TLiteralNumber = exports.TLiteralString = exports.TKindOf = exports.TIterator = exports.TIntersect = exports.TProperties = exports.TInteger = exports.TFunction = exports.TDate = exports.TConstructor = exports.TBoolean = exports.TBigInt = exports.TAsyncIterator = exports.TArray = exports.TAny = exports.TOptional = exports.TReadonly = exports.TypeGuardUnknownTypeError = void 0;
 const ValueGuard = require("./value");
@@ -84,19 +85,30 @@ function IsOptionalFormat(value) {
 function IsOptionalSchema(value) {
     return ValueGuard.IsUndefined(value) || (0, index_2.TSchema)(value);
 }
+// ------------------------------------------------------------------
+// Modifiers
+// ------------------------------------------------------------------
+/** Returns true if this value has a Readonly symbol */
 function TReadonly(value) {
     return ValueGuard.IsObject(value) && value[index_1.ReadonlyKind] === 'Readonly';
 }
 exports.TReadonly = TReadonly;
+/** Returns true if this value has a Optional symbol */
 function TOptional(value) {
     return ValueGuard.IsObject(value) && value[index_1.OptionalKind] === 'Optional';
 }
 exports.TOptional = TOptional;
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+/** Returns true if the given value is TAny */
 function TAny(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Any') &&
         IsOptionalString(value.$id));
 }
 exports.TAny = TAny;
+/** Returns true if the given value is TArray */
 function TArray(value) {
     return (TKindOf(value, 'Array') &&
         value.type === 'array' &&
@@ -110,14 +122,18 @@ function TArray(value) {
         IsOptionalNumber(value.maxContains));
 }
 exports.TArray = TArray;
+/** Returns true if the given value is TAsyncIterator */
 function TAsyncIterator(value) {
+    // prettier-ignore
     return (TKindOf(value, 'AsyncIterator') &&
         value.type === 'AsyncIterator' &&
         IsOptionalString(value.$id) &&
         (0, index_2.TSchema)(value.items));
 }
 exports.TAsyncIterator = TAsyncIterator;
+/** Returns true if the given value is TBigInt */
 function TBigInt(value) {
+    // prettier-ignore
     return (TKindOf(value, 'BigInt') &&
         value.type === 'bigint' &&
         IsOptionalString(value.$id) &&
@@ -128,13 +144,17 @@ function TBigInt(value) {
         IsOptionalBigInt(value.multipleOf));
 }
 exports.TBigInt = TBigInt;
+/** Returns true if the given value is TBoolean */
 function TBoolean(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Boolean') &&
         value.type === 'boolean' &&
         IsOptionalString(value.$id));
 }
 exports.TBoolean = TBoolean;
+/** Returns true if the given value is TConstructor */
 function TConstructor(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Constructor') &&
         value.type === 'Constructor' &&
         IsOptionalString(value.$id) &&
@@ -143,6 +163,7 @@ function TConstructor(value) {
         (0, index_2.TSchema)(value.returns));
 }
 exports.TConstructor = TConstructor;
+/** Returns true if the given value is TDate */
 function TDate(value) {
     return (TKindOf(value, 'Date') &&
         value.type === 'Date' &&
@@ -154,7 +175,9 @@ function TDate(value) {
         IsOptionalNumber(value.multipleOfTimestamp));
 }
 exports.TDate = TDate;
+/** Returns true if the given value is TFunction */
 function TFunction(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Function') &&
         value.type === 'Function' &&
         IsOptionalString(value.$id) &&
@@ -163,6 +186,7 @@ function TFunction(value) {
         (0, index_2.TSchema)(value.returns));
 }
 exports.TFunction = TFunction;
+/** Returns true if the given value is TInteger */
 function TInteger(value) {
     return (TKindOf(value, 'Integer') &&
         value.type === 'integer' &&
@@ -174,12 +198,16 @@ function TInteger(value) {
         IsOptionalNumber(value.multipleOf));
 }
 exports.TInteger = TInteger;
+/** Returns true if the given schema is TProperties */
 function TProperties(value) {
+    // prettier-ignore
     return (ValueGuard.IsObject(value) &&
         Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && (0, index_2.TSchema)(schema)));
 }
 exports.TProperties = TProperties;
+/** Returns true if the given value is TIntersect */
 function TIntersect(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Intersect') &&
         (ValueGuard.IsString(value.type) && value.type !== 'object' ? false : true) &&
         ValueGuard.IsArray(value.allOf) &&
@@ -189,66 +217,86 @@ function TIntersect(value) {
         IsOptionalString(value.$id));
 }
 exports.TIntersect = TIntersect;
+/** Returns true if the given value is TIterator */
 function TIterator(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Iterator') &&
         value.type === 'Iterator' &&
         IsOptionalString(value.$id) &&
         (0, index_2.TSchema)(value.items));
 }
 exports.TIterator = TIterator;
+/** Returns true if the given value is a TKind with the given name. */
 function TKindOf(value, kind) {
     return ValueGuard.IsObject(value) && index_1.Kind in value && value[index_1.Kind] === kind;
 }
 exports.TKindOf = TKindOf;
+/** Returns true if the given value is TLiteral<string> */
 function TLiteralString(value) {
     return (0, index_3.TLiteral)(value) && ValueGuard.IsString(value.const);
 }
 exports.TLiteralString = TLiteralString;
+/** Returns true if the given value is TLiteral<number> */
 function TLiteralNumber(value) {
     return (0, index_3.TLiteral)(value) && ValueGuard.IsNumber(value.const);
 }
 exports.TLiteralNumber = TLiteralNumber;
+/** Returns true if the given value is TLiteral<boolean> */
 function TLiteralBoolean(value) {
     return (0, index_3.TLiteral)(value) && ValueGuard.IsBoolean(value.const);
 }
 exports.TLiteralBoolean = TLiteralBoolean;
+/** Returns true if the given value is TLiteral */
 function TLiteral(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Literal') &&
         IsOptionalString(value.$id) && (0, index_3.TLiteralValue)(value.const));
 }
 exports.TLiteral = TLiteral;
+/** Returns true if the given value is a TLiteralValue */
 function TLiteralValue(value) {
     return ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value) || ValueGuard.IsString(value);
 }
 exports.TLiteralValue = TLiteralValue;
+/** Returns true if the given value is a TMappedKey */
 function TMappedKey(value) {
+    // prettier-ignore
     return (TKindOf(value, 'MappedKey') &&
         ValueGuard.IsArray(value.keys) &&
         value.keys.every(key => ValueGuard.IsNumber(key) || ValueGuard.IsString(key)));
 }
 exports.TMappedKey = TMappedKey;
+/** Returns true if the given value is TMappedResult */
 function TMappedResult(value) {
+    // prettier-ignore
     return (TKindOf(value, 'MappedResult') &&
         (0, index_4.TProperties)(value.properties));
 }
 exports.TMappedResult = TMappedResult;
+/** Returns true if the given value is TNever */
 function TNever(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Never') &&
         ValueGuard.IsObject(value.not) &&
         Object.getOwnPropertyNames(value.not).length === 0);
 }
 exports.TNever = TNever;
+/** Returns true if the given value is TNot */
 function TNot(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Not') &&
         (0, index_2.TSchema)(value.not));
 }
 exports.TNot = TNot;
+/** Returns true if the given value is TNull */
 function TNull(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Null') &&
         value.type === 'null' &&
         IsOptionalString(value.$id));
 }
 exports.TNull = TNull;
+/** Returns true if the given value is TNumber */
 function TNumber(value) {
     return (TKindOf(value, 'Number') &&
         value.type === 'number' &&
@@ -260,7 +308,9 @@ function TNumber(value) {
         IsOptionalNumber(value.multipleOf));
 }
 exports.TNumber = TNumber;
+/** Returns true if the given value is TObject */
 function TObject(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Object') &&
         value.type === 'object' &&
         IsOptionalString(value.$id) &&
@@ -270,14 +320,18 @@ function TObject(value) {
         IsOptionalNumber(value.maxProperties));
 }
 exports.TObject = TObject;
+/** Returns true if the given value is TPromise */
 function TPromise(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Promise') &&
         value.type === 'Promise' &&
         IsOptionalString(value.$id) &&
         (0, index_2.TSchema)(value.item));
 }
 exports.TPromise = TPromise;
+/** Returns true if the given value is TRecord */
 function TRecord(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Record') &&
         value.type === 'object' &&
         IsOptionalString(value.$id) &&
@@ -292,17 +346,22 @@ function TRecord(value) {
         })(value));
 }
 exports.TRecord = TRecord;
+/** Returns true if this value is TRecursive */
 function TRecursive(value) {
     return ValueGuard.IsObject(value) && index_1.Hint in value && value[index_1.Hint] === 'Recursive';
 }
 exports.TRecursive = TRecursive;
+/** Returns true if the given value is TRef */
 function TRef(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Ref') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsString(value.$ref));
 }
 exports.TRef = TRef;
+/** Returns true if the given value is TString */
 function TString(value) {
+    // prettier-ignore
     return (TKindOf(value, 'String') &&
         value.type === 'string' &&
         IsOptionalString(value.$id) &&
@@ -312,13 +371,17 @@ function TString(value) {
         IsOptionalFormat(value.format));
 }
 exports.TString = TString;
+/** Returns true if the given value is TSymbol */
 function TSymbol(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Symbol') &&
         value.type === 'symbol' &&
         IsOptionalString(value.$id));
 }
 exports.TSymbol = TSymbol;
+/** Returns true if the given value is TTemplateLiteral */
 function TTemplateLiteral(value) {
+    // prettier-ignore
     return (TKindOf(value, 'TemplateLiteral') &&
         value.type === 'string' &&
         ValueGuard.IsString(value.pattern) &&
@@ -326,40 +389,51 @@ function TTemplateLiteral(value) {
         value.pattern[value.pattern.length - 1] === '$');
 }
 exports.TTemplateLiteral = TTemplateLiteral;
+/** Returns true if the given value is TThis */
 function TThis(value) {
+    // prettier-ignore
     return (TKindOf(value, 'This') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsString(value.$ref));
 }
 exports.TThis = TThis;
+/** Returns true of this value is TTransform */
 function TTransform(value) {
     return ValueGuard.IsObject(value) && index_1.TransformKind in value;
 }
 exports.TTransform = TTransform;
+/** Returns true if the given value is TTuple */
 function TTuple(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Tuple') &&
         value.type === 'array' &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsNumber(value.minItems) &&
         ValueGuard.IsNumber(value.maxItems) &&
         value.minItems === value.maxItems &&
-        ((ValueGuard.IsUndefined(value.items) &&
+        (( // empty
+        ValueGuard.IsUndefined(value.items) &&
             ValueGuard.IsUndefined(value.additionalItems) &&
             value.minItems === 0) || (ValueGuard.IsArray(value.items) &&
             value.items.every(schema => (0, index_2.TSchema)(schema)))));
 }
 exports.TTuple = TTuple;
+/** Returns true if the given value is TUndefined */
 function TUndefined(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Undefined') &&
         value.type === 'undefined' &&
         IsOptionalString(value.$id));
 }
 exports.TUndefined = TUndefined;
+/** Returns true if the given value is TUnion<Literal<string | number>[]> */
 function TUnionLiteral(value) {
     return (0, index_5.TUnion)(value) && value.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
 }
 exports.TUnionLiteral = TUnionLiteral;
+/** Returns true if the given value is TUnion */
 function TUnion(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Union') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsObject(value) &&
@@ -367,7 +441,9 @@ function TUnion(value) {
         value.anyOf.every(schema => (0, index_2.TSchema)(schema)));
 }
 exports.TUnion = TUnion;
+/** Returns true if the given value is TUint8Array */
 function TUint8Array(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Uint8Array') &&
         value.type === 'Uint8Array' &&
         IsOptionalString(value.$id) &&
@@ -375,26 +451,34 @@ function TUint8Array(value) {
         IsOptionalNumber(value.maxByteLength));
 }
 exports.TUint8Array = TUint8Array;
+/** Returns true if the given value is TUnknown */
 function TUnknown(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Unknown') &&
         IsOptionalString(value.$id));
 }
 exports.TUnknown = TUnknown;
+/** Returns true if the given value is a raw TUnsafe */
 function TUnsafe(value) {
     return TKindOf(value, 'Unsafe');
 }
 exports.TUnsafe = TUnsafe;
+/** Returns true if the given value is TVoid */
 function TVoid(value) {
+    // prettier-ignore
     return (TKindOf(value, 'Void') &&
         value.type === 'void' &&
         IsOptionalString(value.$id));
 }
 exports.TVoid = TVoid;
+/** Returns true if the given value is TKind */
 function TKind(value) {
     return ValueGuard.IsObject(value) && index_1.Kind in value && ValueGuard.IsString(value[index_1.Kind]) && !KnownTypes.includes(value[index_1.Kind]);
 }
 exports.TKind = TKind;
+/** Returns true if the given value is TSchema */
 function TSchema(value) {
+    // prettier-ignore
     return (ValueGuard.IsObject(value)) && ((0, index_6.TAny)(value) ||
         (0, index_7.TArray)(value) ||
         (0, index_8.TBoolean)(value) ||

package/build/require/type/guard/value.d.ts

@@ -1,14 +1,28 @@
+/** Returns true if this value is an async iterator */
 export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<unknown>;
+/** Returns true if this value is an array */
 export declare function IsArray(value: unknown): value is unknown[];
+/** Returns true if this value is bigint */
 export declare function IsBigInt(value: unknown): value is bigint;
+/** Returns true if this value is a boolean */
 export declare function IsBoolean(value: unknown): value is boolean;
+/** Returns true if this value is a Date object */
 export declare function IsDate(value: unknown): value is Date;
+/** Returns true if this value is a function */
 export declare function IsFunction(value: unknown): value is Function;
+/** Returns true if this value is an iterator */
 export declare function IsIterator(value: unknown): value is IterableIterator<unknown>;
+/** Returns true if this value is null */
 export declare function IsNull(value: unknown): value is null;
+/** Returns true if this value is number */
 export declare function IsNumber(value: unknown): value is number;
+/** Returns true if this value is an object */
 export declare function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
+/** Returns true if this value is string */
 export declare function IsString(value: unknown): value is string;
+/** Returns true if this value is symbol */
 export declare function IsSymbol(value: unknown): value is symbol;
+/** Returns true if this value is a Uint8Array */
 export declare function IsUint8Array(value: unknown): value is Uint8Array;
+/** Returns true if this value is undefined */
 export declare function IsUndefined(value: unknown): value is undefined;

package/build/require/type/guard/value.js

@@ -1,58 +1,73 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsUndefined = exports.IsUint8Array = exports.IsSymbol = exports.IsString = exports.IsObject = exports.IsNumber = exports.IsNull = exports.IsIterator = exports.IsFunction = exports.IsDate = exports.IsBoolean = exports.IsBigInt = exports.IsArray = exports.IsAsyncIterator = void 0;
+/** Returns true if this value is an async iterator */
 function IsAsyncIterator(value) {
     return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
 }
 exports.IsAsyncIterator = IsAsyncIterator;
+/** Returns true if this value is an array */
 function IsArray(value) {
     return Array.isArray(value);
 }
 exports.IsArray = IsArray;
+/** Returns true if this value is bigint */
 function IsBigInt(value) {
     return typeof value === 'bigint';
 }
 exports.IsBigInt = IsBigInt;
+/** Returns true if this value is a boolean */
 function IsBoolean(value) {
     return typeof value === 'boolean';
 }
 exports.IsBoolean = IsBoolean;
+/** Returns true if this value is a Date object */
 function IsDate(value) {
     return value instanceof globalThis.Date;
 }
 exports.IsDate = IsDate;
+/** Returns true if this value is a function */
 function IsFunction(value) {
     return typeof value === 'function';
 }
 exports.IsFunction = IsFunction;
+/** Returns true if this value is an iterator */
 function IsIterator(value) {
     return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
 }
 exports.IsIterator = IsIterator;
+/** Returns true if this value is null */
 function IsNull(value) {
     return value === null;
 }
 exports.IsNull = IsNull;
+/** Returns true if this value is number */
 function IsNumber(value) {
     return typeof value === 'number';
 }
 exports.IsNumber = IsNumber;
+/** Returns true if this value is an object */
 function IsObject(value) {
     return typeof value === 'object' && value !== null;
 }
 exports.IsObject = IsObject;
+/** Returns true if this value is string */
 function IsString(value) {
     return typeof value === 'string';
 }
 exports.IsString = IsString;
+/** Returns true if this value is symbol */
 function IsSymbol(value) {
     return typeof value === 'symbol';
 }
 exports.IsSymbol = IsSymbol;
+/** Returns true if this value is a Uint8Array */
 function IsUint8Array(value) {
     return value instanceof globalThis.Uint8Array;
 }
 exports.IsUint8Array = IsUint8Array;
+/** Returns true if this value is undefined */
 function IsUndefined(value) {
     return value === undefined;
 }

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

@@ -34,6 +34,7 @@ type IncrementTake<T extends keyof IncrementBase> = IncrementBase[T];
 type IncrementStep<T extends string> = T extends IncrementBase['m'] ? IncrementBase['t'] : T extends `${infer L extends keyof IncrementBase}${infer R}` ? L extends IncrementBase['m'] ? `${IncrementTake<L>}${IncrementStep<R>}` : `${IncrementTake<L>}${R}` : never;
 type IncrementReverse<T extends string> = T extends `${infer L}${infer R}` ? `${IncrementReverse<R>}${L}` : T;
 export type Increment<T extends string> = IncrementReverse<IncrementStep<IncrementReverse<T>>>;
+/** Increments the given string value + 1 */
 export declare function Increment<T extends string>(T: T): Increment<T>;
 export type AssertProperties<T> = T extends TProperties ? T : TProperties;
 export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : [];