@sinclair/typebox 0.32.0-dev-2 → 0.32.0-dev-4

package/type/any/any.d.ts

@@ -0,0 +1,7 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface TAny extends TSchema {
+    [Kind]: 'Any';
+    static: any;
+}
+export declare function Any(options?: SchemaOptions): TAny;

package/type/any/any.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Any = void 0;
+const index_1 = require("../symbols/index");
+function Any(options = {}) {
+    return { ...options, [index_1.Kind]: 'Any' };
+}
+exports.Any = Any;

package/type/any/index.d.ts

@@ -0,0 +1 @@
+export * from './any';

package/type/any/index.js

@@ -0,0 +1,17 @@
+"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);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./any"), exports);

package/type/array/array.d.ts

@@ -0,0 +1,18 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+export interface ArrayOptions extends SchemaOptions {
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    contains?: TSchema;
+    minContains?: number;
+    maxContains?: number;
+}
+export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
+    [Kind]: 'Array';
+    static: Static<T, this['params']>[];
+    type: 'array';
+    items: T;
+}
+export declare function Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;

package/type/array/array.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Array = void 0;
+const index_1 = require("../symbols/index");
+const type_1 = require("../clone/type");
+function Array(schema, options = {}) {
+    return {
+        ...options,
+        [index_1.Kind]: 'Array',
+        type: 'array',
+        items: (0, type_1.CloneType)(schema),
+    };
+}
+exports.Array = Array;

package/type/array/index.d.ts

@@ -0,0 +1 @@
+export * from './array';

package/type/array/index.js

@@ -0,0 +1,17 @@
+"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);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./array"), exports);

package/type/async-iterator/async-iterator.d.ts

@@ -0,0 +1,10 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'AsyncIterator';
+    static: AsyncIterableIterator<Static<T, this['params']>>;
+    type: 'AsyncIterator';
+    items: T;
+}
+export declare function AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;

package/type/async-iterator/async-iterator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncIterator = void 0;
+const index_1 = require("../symbols/index");
+const type_1 = require("../clone/type");
+function AsyncIterator(items, options = {}) {
+    return {
+        ...options,
+        [index_1.Kind]: 'AsyncIterator',
+        type: 'AsyncIterator',
+        items: (0, type_1.CloneType)(items),
+    };
+}
+exports.AsyncIterator = AsyncIterator;

package/type/async-iterator/index.d.ts

@@ -0,0 +1 @@
+export * from './async-iterator';

package/type/async-iterator/index.js

@@ -0,0 +1,17 @@
+"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);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./async-iterator"), exports);

package/type/awaited/awaited.d.ts

@@ -0,0 +1,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>;
+export {};

package/type/awaited/awaited.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Awaited = exports.Resolve = void 0;
+const index_1 = require("../intersect/index");
+const index_2 = require("../union/index");
+const type_1 = require("../clone/type");
+const type_2 = require("../guard/type");
+function AwaitedUnwrap(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [Resolve(L), ...AwaitedUnwrap(R)]
+        : []);
+}
+function AwaitedIntersectRest(T) {
+    return (0, index_1.Intersect)(AwaitedUnwrap(T));
+}
+function AwaitedUnionRest(T) {
+    return (0, index_2.Union)(AwaitedUnwrap(T));
+}
+function AwaitedPromise(T) {
+    return Resolve(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) :
+                T);
+}
+exports.Resolve = Resolve;
+function Awaited(T, options = {}) {
+    return (0, type_1.CloneType)(Resolve(T), options);
+}
+exports.Awaited = Awaited;

package/type/awaited/index.d.ts

@@ -0,0 +1 @@
+export * from './awaited';

package/type/awaited/index.js

@@ -0,0 +1,17 @@
+"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);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./awaited"), exports);

package/type/bigint/bigint.d.ts

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface BigIntOptions extends SchemaOptions {
+    exclusiveMaximum?: bigint;
+    exclusiveMinimum?: bigint;
+    maximum?: bigint;
+    minimum?: bigint;
+    multipleOf?: bigint;
+}
+export interface TBigInt extends TSchema, BigIntOptions {
+    [Kind]: 'BigInt';
+    static: bigint;
+    type: 'bigint';
+}
+export declare function BigInt(options?: BigIntOptions): TBigInt;

package/type/bigint/bigint.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigInt = void 0;
+const index_1 = require("../symbols/index");
+function BigInt(options = {}) {
+    return {
+        ...options,
+        [index_1.Kind]: 'BigInt',
+        type: 'bigint',
+    };
+}
+exports.BigInt = BigInt;

package/type/bigint/index.d.ts

@@ -0,0 +1 @@
+export * from './bigint';

package/type/bigint/index.js

@@ -0,0 +1,17 @@
+"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);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bigint"), exports);

package/type/boolean/boolean.d.ts

@@ -0,0 +1,8 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface TBoolean extends TSchema {
+    [Kind]: 'Boolean';
+    static: boolean;
+    type: 'boolean';
+}
+export declare function Boolean(options?: SchemaOptions): TBoolean;

package/type/boolean/boolean.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Boolean = void 0;
+const index_1 = require("../symbols/index");
+function Boolean(options = {}) {
+    return {
+        ...options,
+        [index_1.Kind]: 'Boolean',
+        type: 'boolean',
+    };
+}
+exports.Boolean = Boolean;

package/type/boolean/index.d.ts

@@ -0,0 +1 @@
+export * from './boolean';

package/type/boolean/index.js

@@ -0,0 +1,17 @@
+"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);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./boolean"), exports);

package/type/clone/index.d.ts

@@ -0,0 +1,2 @@
+export * as TypeClone from './type';
+export * as ValueClone from './value';

package/type/clone/index.js

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

package/type/clone/type.d.ts

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

package/type/clone/type.js

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

package/type/clone/value.d.ts

@@ -0,0 +1 @@
+export declare function Clone<T>(value: T): T;

package/type/clone/value.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Clone = void 0;
+const ValueGuard = require("../guard/value");
+function ArrayType(value) {
+    return value.map((value) => Visit(value));
+}
+function DateType(value) {
+    return new Date(value.getTime());
+}
+function Uint8ArrayType(value) {
+    return new Uint8Array(value);
+}
+function ObjectType(value) {
+    const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
+    const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
+    return { ...clonedProperties, ...clonedSymbols };
+}
+function Visit(value) {
+    return (ValueGuard.IsArray(value) ? ArrayType(value) :
+        ValueGuard.IsDate(value) ? DateType(value) :
+            ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) :
+                ValueGuard.IsObject(value) ? ObjectType(value) :
+                    value);
+}
+function Clone(value) {
+    return Visit(value);
+}
+exports.Clone = Clone;

package/type/composite/composite.d.ts

@@ -0,0 +1,14 @@
+import type { UnionToTuple, Assert, Evaluate } from '../helpers/index';
+import { type TObject, type ObjectOptions } from '../object/index';
+import { type TIntersect } from '../intersect/index';
+import { IndexedTypeResolve } from '../indexed/index';
+type CompositeKeys<T extends TObject[]> = T extends [infer L extends TObject, ...infer R extends TObject[]] ? keyof L['properties'] | CompositeKeys<R> : never;
+type CompositeIndex<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L extends string, ...infer R extends string[]] ? {
+    [_ in L]: IndexedTypeResolve<T, [L]>;
+} & CompositeIndex<T, R> : {};
+type CompositeReduce<T extends TObject[]> = UnionToTuple<CompositeKeys<T>> extends infer K ? Evaluate<CompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
+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>;
+export declare function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T>;
+export {};

package/type/composite/composite.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Composite = exports.CompositeResolve = void 0;
+const index_1 = require("../object/index");
+const index_2 = require("../intersect/index");
+const index_3 = require("../keyof/index");
+const index_4 = require("../indexed/index");
+const type_1 = require("../clone/type");
+function CompositeResolve(T) {
+    const intersect = (0, index_2.Intersect)(T, {});
+    const keys = (0, index_3.KeyOfStringResolve)(intersect);
+    const properties = keys.reduce((acc, key) => ({ ...acc, [key]: (0, index_4.Index)(intersect, [key]) }), {});
+    return (0, index_1.Object)(properties);
+}
+exports.CompositeResolve = CompositeResolve;
+function Composite(T, options) {
+    return (0, type_1.CloneType)(CompositeResolve(T), options);
+}
+exports.Composite = Composite;

package/type/composite/index.d.ts

@@ -0,0 +1 @@
+export * from './composite';

package/type/composite/index.js

@@ -0,0 +1,17 @@
+"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);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./composite"), exports);

package/type/const/const.d.ts

@@ -0,0 +1,29 @@
+import type { AssertRest, Evaluate } from '../helpers/index';
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { type TAny } from '../any/index';
+import { type TBigInt } from '../bigint/index';
+import { type TDate } from '../date/index';
+import { type TFunction } from '../function/index';
+import { type TLiteral } from '../literal/index';
+import { type TNever } from '../never/index';
+import { type TNull } from '../null/index';
+import { type TObject } from '../object/index';
+import { type TSymbol } from '../symbol/index';
+import { type TTuple } from '../tuple/index';
+import { type TReadonly } from '../readonly/index';
+import { type TUndefined } from '../undefined/index';
+import { type TUint8Array } from '../uint8array/index';
+import { type TUnknown } from '../unknown/index';
+type FromArray<T extends readonly unknown[]> = T extends readonly [infer L extends unknown, ...infer R extends unknown[]] ? [FromValue<L, false>, ...FromArray<R>] : T;
+declare function FromArray<T extends readonly unknown[]>(T: [...T]): FromArray<T>;
+type FromProperties<T extends Record<PropertyKey, unknown>> = {
+    -readonly [K in keyof T]: FromValue<T[K], false> extends infer R extends TSchema ? TReadonly<R> : TReadonly<TNever>;
+};
+declare function FromProperties<T extends Record<PropertyKey, unknown>>(value: T): FromProperties<T>;
+type ConditionalReadonly<T extends TSchema, Root extends boolean> = Root extends true ? T : TReadonly<T>;
+declare function ConditionalReadonly<T extends TSchema, Root extends boolean>(T: T, root: Root): ConditionalReadonly<T, Root>;
+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>;
+export {};

package/type/const/const.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Const = void 0;
+const value_1 = require("../guard/value");
+const index_1 = require("../any/index");
+const index_2 = require("../bigint/index");
+const index_3 = require("../date/index");
+const index_4 = require("../function/index");
+const index_5 = require("../literal/index");
+const index_6 = require("../null/index");
+const index_7 = require("../object/index");
+const index_8 = require("../symbol/index");
+const index_9 = require("../tuple/index");
+const index_10 = require("../readonly/index");
+const index_11 = require("../undefined/index");
+const index_12 = require("../uint8array/index");
+const index_13 = require("../unknown/index");
+const index_14 = require("../clone/index");
+function FromArray(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [FromValue(L, false), ...FromArray(R)]
+        : []);
+}
+function FromProperties(value) {
+    return globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => {
+        return { ...acc, [key]: (0, index_10.Readonly)(FromValue(value[key], false)) };
+    }, {});
+}
+function ConditionalReadonly(T, root) {
+    return (root === true ? T : (0, index_10.Readonly)(T));
+}
+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.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) :
+                            (0, value_1.IsFunction)(value) ? ConditionalReadonly((0, index_4.Function)([], (0, index_13.Unknown)()), root) :
+                                (0, value_1.IsUndefined)(value) ? (0, index_11.Undefined)() :
+                                    (0, value_1.IsNull)(value) ? (0, index_6.Null)() :
+                                        (0, value_1.IsSymbol)(value) ? (0, index_8.Symbol)() :
+                                            (0, value_1.IsBigInt)(value) ? (0, index_2.BigInt)() :
+                                                (0, value_1.IsNumber)(value) ? (0, index_5.Literal)(value) :
+                                                    (0, value_1.IsBoolean)(value) ? (0, index_5.Literal)(value) :
+                                                        (0, value_1.IsString)(value) ? (0, index_5.Literal)(value) :
+                                                            (0, index_7.Object)({}));
+}
+function Const(T, options = {}) {
+    return index_14.TypeClone.CloneType(FromValue(T, true), options);
+}
+exports.Const = Const;

package/type/const/index.d.ts

@@ -0,0 +1 @@
+export * from './const';

package/type/const/index.js

@@ -0,0 +1,17 @@
+"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);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./const"), exports);

package/type/constructor/constructor.d.ts

@@ -0,0 +1,16 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import type { Ensure } from '../helpers/index';
+import { Kind } from '../symbols/index';
+type TConstructorReturnTypeResolve<T extends TSchema, P extends unknown[]> = Static<T, P>;
+type TConstructorParametersResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TConstructorParametersResolve<R, P>] : [];
+export type TConstructorResolve<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: TConstructorParametersResolve<T, P>) => TConstructorReturnTypeResolve<U, P>>);
+export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Constructor';
+    static: TConstructorResolve<T, U, this['params']>;
+    type: 'Constructor';
+    parameters: T;
+    returns: U;
+}
+export declare function Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
+export {};

package/type/constructor/constructor.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Constructor = void 0;
+const index_1 = require("../symbols/index");
+const type_1 = require("../clone/type");
+function Constructor(parameters, returns, options) {
+    return {
+        ...options,
+        [index_1.Kind]: 'Constructor',
+        type: 'Constructor',
+        parameters: (0, type_1.CloneRest)(parameters),
+        returns: (0, type_1.CloneType)(returns),
+    };
+}
+exports.Constructor = Constructor;

package/type/constructor/index.d.ts

@@ -0,0 +1 @@
+export * from './constructor';

package/type/constructor/index.js

@@ -0,0 +1,17 @@
+"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);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constructor"), exports);

package/type/constructor-parameters/constructor-parameters.d.ts

@@ -0,0 +1,6 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+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']>>);
+export declare function ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstructorParameters = void 0;
+const index_1 = require("../tuple/index");
+const type_1 = require("../clone/type");
+function ConstructorParameters(schema, options = {}) {
+    return (0, index_1.Tuple)((0, type_1.CloneRest)(schema.parameters), { ...options });
+}
+exports.ConstructorParameters = ConstructorParameters;

package/type/constructor-parameters/index.d.ts

@@ -0,0 +1 @@
+export * from './constructor-parameters';