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

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

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

package/build/require/type/awaited/awaited.js

@@ -1,33 +1,43 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Awaited = exports.Resolve = void 0;
+exports.Awaited = void 0;
 const index_1 = require("../intersect/index");
 const index_2 = require("../union/index");
 const type_1 = require("../clone/type");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
-function AwaitedUnwrap(T) {
+// prettier-ignore
+function FromRest(T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [Resolve(L), ...AwaitedUnwrap(R)]
+        ? [FromSchema(L), ...FromRest(R)]
         : []);
 }
-function AwaitedIntersectRest(T) {
-    return (0, index_1.Intersect)(AwaitedUnwrap(T));
+// prettier-ignore
+function FromIntersect(T) {
+    return (0, index_1.Intersect)(FromRest(T));
 }
-function AwaitedUnionRest(T) {
-    return (0, index_2.Union)(AwaitedUnwrap(T));
+// prettier-ignore
+function FromUnion(T) {
+    return (0, index_2.Union)(FromRest(T));
 }
-function AwaitedPromise(T) {
-    return Resolve(T);
+// prettier-ignore
+function FromPromise(T) {
+    return FromSchema(T);
 }
-function Resolve(T) {
-    return ((0, type_2.TIntersect)(T) ? AwaitedIntersectRest(T.allOf) :
-        (0, type_2.TUnion)(T) ? AwaitedUnionRest(T.anyOf) :
-            (0, type_2.TPromise)(T) ? AwaitedPromise(T.item) :
+// prettier-ignore
+function FromSchema(T) {
+    return ((0, type_2.TIntersect)(T) ? FromIntersect(T.allOf) :
+        (0, type_2.TUnion)(T) ? FromUnion(T.anyOf) :
+            (0, type_2.TPromise)(T) ? FromPromise(T.item) :
                 T);
 }
-exports.Resolve = Resolve;
+/** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
 function Awaited(T, options = {}) {
-    return (0, type_1.CloneType)(Resolve(T), options);
+    return (0, type_1.CloneType)(FromSchema(T), options);
 }
 exports.Awaited = Awaited;

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

@@ -12,4 +12,5 @@ export interface TBigInt extends TSchema, BigIntOptions {
     static: bigint;
     type: 'bigint';
 }
+/** `[JavaScript]` Creates a BigInt type */
 export declare function BigInt(options?: BigIntOptions): TBigInt;

package/build/require/type/bigint/bigint.js

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

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

@@ -5,4 +5,5 @@ export interface TBoolean extends TSchema {
     static: boolean;
     type: 'boolean';
 }
+/** `[Json]` Creates a Boolean type */
 export declare function Boolean(options?: SchemaOptions): TBoolean;

package/build/require/type/boolean/boolean.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Boolean = void 0;
 const index_1 = require("../symbols/index");
+/** `[Json]` Creates a Boolean type */
 function Boolean(options = {}) {
     return {
         ...options,

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

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

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

@@ -1,3 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
+/** Clones a Rest */
 export declare function CloneRest<T extends TSchema[]>(schemas: T): T;
+/** Clones a Type */
 export declare function CloneType<T extends TSchema>(schema: T, options?: SchemaOptions): T;

package/build/require/type/clone/type.js

@@ -1,11 +1,14 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CloneType = exports.CloneRest = void 0;
 const value_1 = require("./value");
+/** Clones a Rest */
 function CloneRest(schemas) {
     return schemas.map((schema) => CloneType(schema));
 }
 exports.CloneRest = CloneRest;
+/** Clones a Type */
 function CloneType(schema, options = {}) {
     return { ...(0, value_1.Clone)(schema), ...options };
 }

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

@@ -1 +1,2 @@
+/** Clones a value */
 export declare function Clone<T>(value: T): T;

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

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Clone = void 0;
 const ValueGuard = require("../guard/value");
@@ -16,6 +17,7 @@ function ObjectType(value) {
     const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
     return { ...clonedProperties, ...clonedSymbols };
 }
+// prettier-ignore
 function Visit(value) {
     return (ValueGuard.IsArray(value) ? ArrayType(value) :
         ValueGuard.IsDate(value) ? DateType(value) :
@@ -23,6 +25,7 @@ function Visit(value) {
                 ValueGuard.IsObject(value) ? ObjectType(value) :
                     value);
 }
+/** Clones a value */
 function Clone(value) {
     return Visit(value);
 }

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

@@ -10,5 +10,6 @@ type CompositeReduce<T extends TObject[]> = UnionToTuple<CompositeKeys<T>> exten
 export type CompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<CompositeReduce<T>> : TObject<{}>;
 export declare function CompositeResolve<T extends TObject[]>(T: [...T]): CompositeResolve<T>;
 export type TComposite<T extends TObject[]> = CompositeResolve<T>;
+/** `[Json]` Creates a Composite object type */
 export declare function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T>;
 export {};

package/build/require/type/composite/composite.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Composite = exports.CompositeResolve = void 0;
 const index_1 = require("../object/index");
@@ -13,6 +14,7 @@ function CompositeResolve(T) {
     return (0, index_1.Object)(properties);
 }
 exports.CompositeResolve = CompositeResolve;
+/** `[Json]` Creates a Composite object type */
 function Composite(T, options) {
     return (0, type_1.CloneType)(CompositeResolve(T), options);
 }

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

@@ -25,5 +25,6 @@ declare function ConditionalReadonly<T extends TSchema, Root extends boolean>(T:
 type FromValue<T, Root extends boolean> = T extends AsyncIterableIterator<unknown> ? ConditionalReadonly<TAny, Root> : T extends IterableIterator<unknown> ? ConditionalReadonly<TAny, Root> : T extends readonly unknown[] ? TReadonly<TTuple<AssertRest<FromArray<T>>>> : T extends Uint8Array ? TUint8Array : T extends Date ? TDate : T extends Record<PropertyKey, unknown> ? ConditionalReadonly<TObject<Evaluate<FromProperties<T>>>, Root> : T extends Function ? ConditionalReadonly<TFunction<[], TUnknown>, Root> : T extends undefined ? TUndefined : T extends null ? TNull : T extends symbol ? TSymbol : T extends number ? TLiteral<T> : T extends boolean ? TLiteral<T> : T extends string ? TLiteral<T> : T extends bigint ? TBigInt : TObject<{}>;
 declare function FromValue<T, Root extends boolean>(value: T, root: Root): FromValue<T, Root>;
 export type TConst<T> = FromValue<T, true>;
-export declare function Const<T>(T: T, options?: SchemaOptions): TConst<T>;
+/** `[JavaScript]` Creates a readonly const type from the given value. */
+export declare function Const</* const (not supported in 4.0) */ T>(T: T, options?: SchemaOptions): TConst<T>;
 export {};

package/build/require/type/const/const.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Const = void 0;
 const value_1 = require("../guard/value");
@@ -16,12 +17,14 @@ const index_11 = require("../undefined/index");
 const index_12 = require("../uint8array/index");
 const index_13 = require("../unknown/index");
 const index_14 = require("../clone/index");
+// prettier-ignore
 function FromArray(T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [FromValue(L, false), ...FromArray(R)]
         : []);
 }
+// prettier-ignore
 function FromProperties(value) {
     return globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => {
         return { ...acc, [key]: (0, index_10.Readonly)(FromValue(value[key], false)) };
@@ -30,10 +33,11 @@ function FromProperties(value) {
 function ConditionalReadonly(T, root) {
     return (root === true ? T : (0, index_10.Readonly)(T));
 }
+// prettier-ignore
 function FromValue(value, root) {
     return ((0, value_1.IsAsyncIterator)(value) ? ConditionalReadonly((0, index_1.Any)(), root) :
         (0, value_1.IsIterator)(value) ? ConditionalReadonly((0, index_1.Any)(), root) :
-            (0, value_1.IsArray)(value) ? (0, index_10.Readonly)((0, index_9.Tuple)(FromArray(value))) :
+            (0, value_1.IsArray)(value) ? (0, index_10.Readonly)((0, index_9.Tuple)(FromArray(value))) : // Always Readonly
                 (0, value_1.IsUint8Array)(value) ? (0, index_12.Uint8Array)() :
                     (0, value_1.IsDate)(value) ? (0, index_3.Date)() :
                         (0, value_1.IsObject)(value) ? ConditionalReadonly((0, index_7.Object)(FromProperties(value)), root) :
@@ -47,6 +51,7 @@ function FromValue(value, root) {
                                                         (0, value_1.IsString)(value) ? (0, index_5.Literal)(value) :
                                                             (0, index_7.Object)({}));
 }
+/** `[JavaScript]` Creates a readonly const type from the given value. */
 function Const(T, options = {}) {
     return index_14.TypeClone.CloneType(FromValue(T, true), options);
 }

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

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

package/build/require/type/constructor/constructor.js

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

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

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

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

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

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

@@ -1,10 +1,15 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import { Kind } from '../symbols/index';
 export interface DateOptions extends SchemaOptions {
+    /** The exclusive maximum timestamp value */
     exclusiveMaximumTimestamp?: number;
+    /** The exclusive minimum timestamp value */
     exclusiveMinimumTimestamp?: number;
+    /** The maximum timestamp value */
     maximumTimestamp?: number;
+    /** The minimum timestamp value */
     minimumTimestamp?: number;
+    /** The multiple of timestamp value */
     multipleOfTimestamp?: number;
 }
 export interface TDate extends TSchema, DateOptions {
@@ -12,4 +17,5 @@ export interface TDate extends TSchema, DateOptions {
     static: Date;
     type: 'date';
 }
+/** `[JavaScript]` Creates a Date type */
 export declare function Date(options?: DateOptions): TDate;

package/build/require/type/date/date.js

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

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

@@ -19,5 +19,6 @@ declare function FromProperties(properties: TProperties, references: TSchema[]):
 export type DerefResolve<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<FromRest<S>, DerefResolve<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<FromRest<S>, DerefResolve<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<FromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<FromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<FromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<DerefResolve<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<DerefResolve<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DerefResolve<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DerefResolve<S>> : T extends TRef<infer S extends TSchema> ? DerefResolve<S> : T;
 export declare function DerefResolve<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
 export type TDeref<T extends TSchema> = DerefResolve<T>;
+/** `[Json]` Creates a dereferenced type */
 export declare function Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
 export {};

package/build/require/type/deref/deref.js

@@ -1,40 +1,51 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Deref = exports.DerefResolve = void 0;
 const type_1 = require("../clone/type");
 const index_1 = require("../discard/index");
 const value_1 = require("../guard/value");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
 function FromRest(schema, references) {
     return schema.map((schema) => Deref(schema, references));
 }
+// prettier-ignore
 function FromProperties(properties, references) {
     return globalThis.Object.getOwnPropertyNames(properties).reduce((acc, key) => {
         return { ...acc, [key]: Deref(properties[key], references) };
     }, {});
 }
+// prettier-ignore
 function FromConstructor(schema, references) {
     const clone = (0, type_1.CloneType)(schema);
     clone.parameters = FromRest(clone.parameters, references);
     clone.returns = Deref(clone.returns, references);
     return clone;
 }
+// prettier-ignore
 function FromFunction(schema, references) {
     const clone = (0, type_1.CloneType)(schema);
     clone.parameters = FromRest(clone.parameters, references);
     clone.returns = Deref(clone.returns, references);
     return clone;
 }
+// prettier-ignore
 function FromIntersect(schema, references) {
     const clone = (0, type_1.CloneType)(schema);
     clone.allOf = FromRest(clone.allOf, references);
     return clone;
 }
+// prettier-ignore
 function FromUnion(schema, references) {
     const clone = (0, type_1.CloneType)(schema);
     clone.anyOf = FromRest(clone.anyOf, references);
     return clone;
 }
+// prettier-ignore
 function FromTuple(schema, references) {
     const clone = (0, type_1.CloneType)(schema);
     if ((0, value_1.IsUndefined)(clone.items))
@@ -42,31 +53,37 @@ function FromTuple(schema, references) {
     clone.items = FromRest(clone.items, references);
     return clone;
 }
+// prettier-ignore
 function FromArray(schema, references) {
     const clone = (0, type_1.CloneType)(schema);
     clone.items = Deref(clone.items, references);
     return clone;
 }
+// prettier-ignore
 function FromObject(schema, references) {
     const clone = (0, type_1.CloneType)(schema);
     clone.properties = FromProperties(clone.properties, references);
     return clone;
 }
+// prettier-ignore
 function FromPromise(schema, references) {
     const clone = (0, type_1.CloneType)(schema);
     clone.item = Deref(clone.item, references);
     return clone;
 }
+// prettier-ignore
 function FromAsyncIterator(schema, references) {
     const clone = (0, type_1.CloneType)(schema);
     clone.items = Deref(clone.items, references);
     return clone;
 }
+// prettier-ignore
 function FromIterator(schema, references) {
     const clone = (0, type_1.CloneType)(schema);
     clone.items = Deref(clone.items, references);
     return clone;
 }
+// prettier-ignore
 function FromRef(schema, references) {
     const target = references.find(remote => remote.$id === schema.$ref);
     if (target === undefined)
@@ -74,6 +91,7 @@ function FromRef(schema, references) {
     const discard = (0, index_1.Discard)(target, ['$id']);
     return Deref(discard, references);
 }
+// prettier-ignore
 function DerefResolve(schema, references) {
     return ((0, type_2.TConstructor)(schema) ? FromConstructor(schema, references) :
         (0, type_2.TFunction)(schema) ? FromFunction(schema, references) :
@@ -89,6 +107,7 @@ function DerefResolve(schema, references) {
                                                 schema);
 }
 exports.DerefResolve = DerefResolve;
+/** `[Json]` Creates a dereferenced type */
 function Deref(schema, references) {
     return DerefResolve(schema, references);
 }

package/build/require/type/deref/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/discard/discard.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Discard = void 0;
 function Key(value, key) {

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

@@ -10,4 +10,5 @@ export interface TEnum<T extends Record<string, string | number> = Record<string
     static: T[keyof T];
     anyOf: TLiteral<T[keyof T]>[];
 }
+/** `[Json]` Creates a Enum type */
 export declare function Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;

package/build/require/type/enum/enum.js

@@ -1,10 +1,12 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Enum = void 0;
 const index_1 = require("../literal/index");
 const index_2 = require("../symbols/index");
 const index_3 = require("../union/index");
 const value_1 = require("../guard/value");
+/** `[Json]` Creates a Enum type */
 function Enum(item, options = {}) {
     if ((0, value_1.IsUndefined)(item))
         throw new Error('Enum undefined or empty');

package/build/require/type/enum/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/exclude/exclude-from-mapped-result.js

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

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

@@ -18,6 +18,8 @@ type ExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTu
 type ExcludeResolve<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? ExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? ExcludeArray<S, U> : T extends U ? TNever : T;
 declare function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExcludeResolve<L, R>;
 export type TExclude<T extends TSchema, U extends TSchema> = ExcludeResolve<T, U>;
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
 export declare function 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 */
 export declare function Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
 export {};

package/build/require/type/exclude/exclude.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Exclude = 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 exclude_from_mapped_result_1 = require("./exclude-from-mapped-result");
+// prettier-ignore
 const type_2 = require("../guard/type");
+// prettier-ignore
 function ExcludeResolve(L, R) {
     return ((0, type_2.TTemplateLiteral)(L) ? ExcludeResolve((0, index_1.TemplateLiteralToUnion)(L), R) :
         (0, type_2.TTemplateLiteral)(R) ? ExcludeResolve(L, (0, index_1.TemplateLiteralToUnion)(R)) :
@@ -18,6 +21,7 @@ function ExcludeResolve(L, R) {
                 (0, index_4.ExtendsCheck)(L, R) !== index_4.ExtendsResult.False ? (0, index_3.Never)() :
                     L);
 }
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
 function Exclude(unionType, excludedMembers, options = {}) {
     if ((0, type_2.TMappedResult)(unionType)) {
         return (0, exclude_from_mapped_result_1.ExcludeFromMappedResult)(unionType, excludedMembers, options);

package/build/require/type/exclude/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);