@depup/sinclair__typebox 0.34.48-depup.0

package/build/cjs/type/mapped/mapped.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MappedFunctionReturnType = MappedFunctionReturnType;
+exports.Mapped = Mapped;
+const index_1 = require("../symbols/index");
+const index_2 = require("../discard/index");
+// evaluation types
+const index_3 = require("../array/index");
+const index_4 = require("../async-iterator/index");
+const index_5 = require("../constructor/index");
+const index_6 = require("../function/index");
+const index_7 = require("../indexed/index");
+const index_8 = require("../intersect/index");
+const index_9 = require("../iterator/index");
+const index_10 = require("../literal/index");
+const index_11 = require("../object/index");
+const index_12 = require("../optional/index");
+const index_13 = require("../promise/index");
+const index_14 = require("../readonly/index");
+const index_15 = require("../tuple/index");
+const index_16 = require("../union/index");
+// operator
+const index_17 = require("../sets/index");
+// mapping types
+const mapped_result_1 = require("./mapped-result");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+const kind_1 = require("../guard/kind");
+// prettier-ignore
+function FromMappedResult(K, P) {
+    return (K in P
+        ? FromSchemaType(K, P[K])
+        : (0, mapped_result_1.MappedResult)(P));
+}
+// prettier-ignore
+function MappedKeyToKnownMappedResultProperties(K) {
+    return { [K]: (0, index_10.Literal)(K) };
+}
+// prettier-ignore
+function MappedKeyToUnknownMappedResultProperties(P) {
+    const Acc = {};
+    for (const L of P)
+        Acc[L] = (0, index_10.Literal)(L);
+    return Acc;
+}
+// prettier-ignore
+function MappedKeyToMappedResultProperties(K, P) {
+    return ((0, index_17.SetIncludes)(P, K)
+        ? MappedKeyToKnownMappedResultProperties(K)
+        : MappedKeyToUnknownMappedResultProperties(P));
+}
+// prettier-ignore
+function FromMappedKey(K, P) {
+    const R = MappedKeyToMappedResultProperties(K, P);
+    return FromMappedResult(K, R);
+}
+// prettier-ignore
+function FromRest(K, T) {
+    return T.map(L => FromSchemaType(K, L));
+}
+// prettier-ignore
+function FromProperties(K, T) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(T))
+        Acc[K2] = FromSchemaType(K, T[K2]);
+    return Acc;
+}
+// prettier-ignore
+function FromSchemaType(K, T) {
+    // required to retain user defined options for mapped type
+    const options = { ...T };
+    return (
+    // unevaluated modifier types
+    (0, kind_1.IsOptional)(T) ? (0, index_12.Optional)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.OptionalKind]))) :
+        (0, kind_1.IsReadonly)(T) ? (0, index_14.Readonly)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.ReadonlyKind]))) :
+            // unevaluated mapped types
+            (0, kind_1.IsMappedResult)(T) ? FromMappedResult(K, T.properties) :
+                (0, kind_1.IsMappedKey)(T) ? FromMappedKey(K, T.keys) :
+                    // unevaluated types
+                    (0, kind_1.IsConstructor)(T) ? (0, index_5.Constructor)(FromRest(K, T.parameters), FromSchemaType(K, T.returns), options) :
+                        (0, kind_1.IsFunction)(T) ? (0, index_6.Function)(FromRest(K, T.parameters), FromSchemaType(K, T.returns), options) :
+                            (0, kind_1.IsAsyncIterator)(T) ? (0, index_4.AsyncIterator)(FromSchemaType(K, T.items), options) :
+                                (0, kind_1.IsIterator)(T) ? (0, index_9.Iterator)(FromSchemaType(K, T.items), options) :
+                                    (0, kind_1.IsIntersect)(T) ? (0, index_8.Intersect)(FromRest(K, T.allOf), options) :
+                                        (0, kind_1.IsUnion)(T) ? (0, index_16.Union)(FromRest(K, T.anyOf), options) :
+                                            (0, kind_1.IsTuple)(T) ? (0, index_15.Tuple)(FromRest(K, T.items ?? []), options) :
+                                                (0, kind_1.IsObject)(T) ? (0, index_11.Object)(FromProperties(K, T.properties), options) :
+                                                    (0, kind_1.IsArray)(T) ? (0, index_3.Array)(FromSchemaType(K, T.items), options) :
+                                                        (0, kind_1.IsPromise)(T) ? (0, index_13.Promise)(FromSchemaType(K, T.item), options) :
+                                                            T);
+}
+// prettier-ignore
+function MappedFunctionReturnType(K, T) {
+    const Acc = {};
+    for (const L of K)
+        Acc[L] = FromSchemaType(L, T);
+    return Acc;
+}
+/** `[Json]` Creates a Mapped object type */
+function Mapped(key, map, options) {
+    const K = (0, kind_1.IsSchema)(key) ? (0, index_7.IndexPropertyKeys)(key) : key;
+    const RT = map({ [index_1.Kind]: 'MappedKey', keys: K });
+    const R = MappedFunctionReturnType(K, RT);
+    return (0, index_11.Object)(R, options);
+}

package/build/cjs/type/module/compute.d.ts

@@ -0,0 +1,59 @@
+import { Ensure, Evaluate } from '../helpers/index';
+import { type TSchema } from '../schema/index';
+import { type TArray } from '../array/index';
+import { type TAwaited } from '../awaited/index';
+import { type TAsyncIterator } from '../async-iterator/index';
+import { TComputed } from '../computed/index';
+import { type TConstructor } from '../constructor/index';
+import { type TIndex, type TIndexPropertyKeys } from '../indexed/index';
+import { TEnum, type TEnumRecord } from '../enum/index';
+import { type TFunction } from '../function/index';
+import { type TIntersect, type TIntersectEvaluated } from '../intersect/index';
+import { type TIterator } from '../iterator/index';
+import { type TKeyOf } from '../keyof/index';
+import { type TObject, type TProperties } from '../object/index';
+import { type TOmit } from '../omit/index';
+import { type TOptional } from '../optional/index';
+import { type TPick } from '../pick/index';
+import { type TNever } from '../never/index';
+import { TPartial } from '../partial/index';
+import { type TReadonly } from '../readonly/index';
+import { type TRecordOrObject, type TRecord } from '../record/index';
+import { type TRef } from '../ref/index';
+import { type TRequired } from '../required/index';
+import { type TTransform } from '../transform/index';
+import { type TTuple } from '../tuple/index';
+import { type TUnion, type TUnionEvaluated } from '../union/index';
+type TDereferenceParameters<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TRef<infer Key extends string> ? TDereferenceParameters<ModuleProperties, Right, [...Result, TDereference<ModuleProperties, Key>]> : TDereferenceParameters<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]> : Result);
+type TDereference<ModuleProperties extends TProperties, Ref extends string, Result extends TSchema = (Ref extends keyof ModuleProperties ? ModuleProperties[Ref] extends TRef<infer Ref2 extends string> ? TDereference<ModuleProperties, Ref2> : TFromType<ModuleProperties, ModuleProperties[Ref]> : TNever)> = Result;
+type TFromAwaited<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema] ? TAwaited<T0> : never);
+type TFromIndex<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TIndex<T0, TIndexPropertyKeys<T1>> extends infer Result extends TSchema ? Result : never : never);
+type TFromKeyOf<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema] ? TKeyOf<T0> : never);
+type TFromPartial<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema] ? TPartial<T0> : never);
+type TFromOmit<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TOmit<T0, T1> : never);
+type TFromPick<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TPick<T0, T1> : never);
+type TFromRequired<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema] ? TRequired<T0> : never);
+type TFromComputed<ModuleProperties extends TProperties, Target extends string, Parameters extends TSchema[], Dereferenced extends TSchema[] = TDereferenceParameters<ModuleProperties, Parameters>> = (Target extends 'Awaited' ? TFromAwaited<Dereferenced> : Target extends 'Index' ? TFromIndex<Dereferenced> : Target extends 'KeyOf' ? TFromKeyOf<Dereferenced> : Target extends 'Partial' ? TFromPartial<Dereferenced> : Target extends 'Omit' ? TFromOmit<Dereferenced> : Target extends 'Pick' ? TFromPick<Dereferenced> : Target extends 'Required' ? TFromRequired<Dereferenced> : TNever);
+type TFromArray<ModuleProperties extends TProperties, Type extends TSchema> = (Ensure<TArray<TFromType<ModuleProperties, Type>>>);
+type TFromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TAsyncIterator<TFromType<ModuleProperties, Type>>);
+type TFromConstructor<ModuleProperties extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema> = (TConstructor<TFromTypes<ModuleProperties, Parameters>, TFromType<ModuleProperties, InstanceType>>);
+type TFromFunction<ModuleProperties extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema> = Ensure<Ensure<TFunction<TFromTypes<ModuleProperties, Parameters>, TFromType<ModuleProperties, ReturnType>>>>;
+type TFromIntersect<ModuleProperties extends TProperties, Types extends TSchema[]> = (Ensure<TIntersectEvaluated<TFromTypes<ModuleProperties, Types>>>);
+type TFromIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TIterator<TFromType<ModuleProperties, Type>>);
+type TFromObject<ModuleProperties extends TProperties, Properties extends TProperties> = Ensure<TObject<Evaluate<{
+    [Key in keyof Properties]: TFromType<ModuleProperties, Properties[Key]>;
+}>>>;
+type TFromRecord<ModuleProperties extends TProperties, Key extends TSchema, Value extends TSchema, Result extends TSchema = TRecordOrObject<Key, TFromType<ModuleProperties, Value>>> = Result;
+type TFromTransform<ModuleProperties extends TProperties, Input extends TSchema, Output extends unknown, Result extends TSchema = Input extends TRef<infer Key extends string> ? TTransform<TDereference<ModuleProperties, Key>, Output> : TTransform<Input, Output>> = Result;
+type TFromTuple<ModuleProperties extends TProperties, Types extends TSchema[]> = (Ensure<TTuple<TFromTypes<ModuleProperties, Types>>>);
+type TFromUnion<ModuleProperties extends TProperties, Types extends TSchema[]> = (Ensure<TUnionEvaluated<TFromTypes<ModuleProperties, Types>>>);
+type TFromTypes<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]> : Result);
+export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TOptional<infer Type extends TSchema> ? TOptional<TFromType<ModuleProperties, Type>> : Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TFromType<ModuleProperties, Type>> : Type extends TTransform<infer Input extends TSchema, infer Output extends unknown> ? TFromTransform<ModuleProperties, Input, Output> : Type extends TArray<infer Type extends TSchema> ? TFromArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<ModuleProperties, Type> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<ModuleProperties, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<ModuleProperties, Properties> : Type extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TFromRecord<ModuleProperties, Key, Value> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Type : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<ModuleProperties, Types> : Type);
+export declare function FromType<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromType<ModuleProperties, Type>;
+export type TComputeType<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TFromType<ModuleProperties, ModuleProperties[Key]> : TNever);
+export declare function ComputeType<ModuleProperties extends TProperties, Key extends PropertyKey>(moduleProperties: ModuleProperties, key: Key): TComputeType<ModuleProperties, Key>;
+export type TComputeModuleProperties<ModuleProperties extends TProperties> = Evaluate<{
+    [Key in keyof ModuleProperties]: TComputeType<ModuleProperties, Key>;
+}>;
+export declare function ComputeModuleProperties<ModuleProperties extends TProperties>(moduleProperties: ModuleProperties): TComputeModuleProperties<ModuleProperties>;
+export {};

package/build/cjs/type/module/compute.js

@@ -0,0 +1,205 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromType = FromType;
+exports.ComputeType = ComputeType;
+exports.ComputeModuleProperties = ComputeModuleProperties;
+const index_1 = require("../create/index");
+const index_2 = require("../clone/index");
+const index_3 = require("../discard/index");
+const index_4 = require("../array/index");
+const index_5 = require("../awaited/index");
+const index_6 = require("../async-iterator/index");
+const index_7 = require("../constructor/index");
+const index_8 = require("../indexed/index");
+const index_9 = require("../function/index");
+const index_10 = require("../intersect/index");
+const index_11 = require("../iterator/index");
+const index_12 = require("../keyof/index");
+const index_13 = require("../object/index");
+const index_14 = require("../omit/index");
+const index_15 = require("../pick/index");
+const index_16 = require("../never/index");
+const index_17 = require("../partial/index");
+const index_18 = require("../record/index");
+const index_19 = require("../required/index");
+const index_20 = require("../tuple/index");
+const index_21 = require("../union/index");
+// ------------------------------------------------------------------
+// Symbols
+// ------------------------------------------------------------------
+const index_22 = require("../symbols/index");
+// ------------------------------------------------------------------
+// KindGuard
+// ------------------------------------------------------------------
+const KindGuard = __importStar(require("../guard/kind"));
+// prettier-ignore
+function DereferenceParameters(moduleProperties, types) {
+    return types.map((type) => {
+        return KindGuard.IsRef(type)
+            ? Dereference(moduleProperties, type.$ref)
+            : FromType(moduleProperties, type);
+    });
+}
+// prettier-ignore
+function Dereference(moduleProperties, ref) {
+    return (ref in moduleProperties
+        ? KindGuard.IsRef(moduleProperties[ref])
+            ? Dereference(moduleProperties, moduleProperties[ref].$ref)
+            : FromType(moduleProperties, moduleProperties[ref])
+        : (0, index_16.Never)());
+}
+// prettier-ignore
+function FromAwaited(parameters) {
+    return (0, index_5.Awaited)(parameters[0]);
+}
+// prettier-ignore
+function FromIndex(parameters) {
+    return (0, index_8.Index)(parameters[0], parameters[1]);
+}
+// prettier-ignore
+function FromKeyOf(parameters) {
+    return (0, index_12.KeyOf)(parameters[0]);
+}
+// prettier-ignore
+function FromPartial(parameters) {
+    return (0, index_17.Partial)(parameters[0]);
+}
+// prettier-ignore
+function FromOmit(parameters) {
+    return (0, index_14.Omit)(parameters[0], parameters[1]);
+}
+// prettier-ignore
+function FromPick(parameters) {
+    return (0, index_15.Pick)(parameters[0], parameters[1]);
+}
+// prettier-ignore
+function FromRequired(parameters) {
+    return (0, index_19.Required)(parameters[0]);
+}
+// prettier-ignore
+function FromComputed(moduleProperties, target, parameters) {
+    const dereferenced = DereferenceParameters(moduleProperties, parameters);
+    return (target === 'Awaited' ? FromAwaited(dereferenced) :
+        target === 'Index' ? FromIndex(dereferenced) :
+            target === 'KeyOf' ? FromKeyOf(dereferenced) :
+                target === 'Partial' ? FromPartial(dereferenced) :
+                    target === 'Omit' ? FromOmit(dereferenced) :
+                        target === 'Pick' ? FromPick(dereferenced) :
+                            target === 'Required' ? FromRequired(dereferenced) :
+                                (0, index_16.Never)());
+}
+function FromArray(moduleProperties, type) {
+    return (0, index_4.Array)(FromType(moduleProperties, type));
+}
+function FromAsyncIterator(moduleProperties, type) {
+    return (0, index_6.AsyncIterator)(FromType(moduleProperties, type));
+}
+// prettier-ignore
+function FromConstructor(moduleProperties, parameters, instanceType) {
+    return (0, index_7.Constructor)(FromTypes(moduleProperties, parameters), FromType(moduleProperties, instanceType));
+}
+// prettier-ignore
+function FromFunction(moduleProperties, parameters, returnType) {
+    return (0, index_9.Function)(FromTypes(moduleProperties, parameters), FromType(moduleProperties, returnType));
+}
+function FromIntersect(moduleProperties, types) {
+    return (0, index_10.Intersect)(FromTypes(moduleProperties, types));
+}
+function FromIterator(moduleProperties, type) {
+    return (0, index_11.Iterator)(FromType(moduleProperties, type));
+}
+function FromObject(moduleProperties, properties) {
+    return (0, index_13.Object)(globalThis.Object.keys(properties).reduce((result, key) => {
+        return { ...result, [key]: FromType(moduleProperties, properties[key]) };
+    }, {}));
+}
+// prettier-ignore
+function FromRecord(moduleProperties, type) {
+    const [value, pattern] = [FromType(moduleProperties, (0, index_18.RecordValue)(type)), (0, index_18.RecordPattern)(type)];
+    const result = (0, index_2.CloneType)(type);
+    result.patternProperties[pattern] = value;
+    return result;
+}
+// prettier-ignore
+function FromTransform(moduleProperties, transform) {
+    return (KindGuard.IsRef(transform))
+        ? { ...Dereference(moduleProperties, transform.$ref), [index_22.TransformKind]: transform[index_22.TransformKind] }
+        : transform;
+}
+function FromTuple(moduleProperties, types) {
+    return (0, index_20.Tuple)(FromTypes(moduleProperties, types));
+}
+function FromUnion(moduleProperties, types) {
+    return (0, index_21.Union)(FromTypes(moduleProperties, types));
+}
+function FromTypes(moduleProperties, types) {
+    return types.map((type) => FromType(moduleProperties, type));
+}
+// prettier-ignore
+function FromType(moduleProperties, type) {
+    return (
+    // Modifiers
+    KindGuard.IsOptional(type) ? (0, index_1.CreateType)(FromType(moduleProperties, (0, index_3.Discard)(type, [index_22.OptionalKind])), type) :
+        KindGuard.IsReadonly(type) ? (0, index_1.CreateType)(FromType(moduleProperties, (0, index_3.Discard)(type, [index_22.ReadonlyKind])), type) :
+            // Transform
+            KindGuard.IsTransform(type) ? (0, index_1.CreateType)(FromTransform(moduleProperties, type), type) :
+                // Types
+                KindGuard.IsArray(type) ? (0, index_1.CreateType)(FromArray(moduleProperties, type.items), type) :
+                    KindGuard.IsAsyncIterator(type) ? (0, index_1.CreateType)(FromAsyncIterator(moduleProperties, type.items), type) :
+                        KindGuard.IsComputed(type) ? (0, index_1.CreateType)(FromComputed(moduleProperties, type.target, type.parameters)) :
+                            KindGuard.IsConstructor(type) ? (0, index_1.CreateType)(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
+                                KindGuard.IsFunction(type) ? (0, index_1.CreateType)(FromFunction(moduleProperties, type.parameters, type.returns), type) :
+                                    KindGuard.IsIntersect(type) ? (0, index_1.CreateType)(FromIntersect(moduleProperties, type.allOf), type) :
+                                        KindGuard.IsIterator(type) ? (0, index_1.CreateType)(FromIterator(moduleProperties, type.items), type) :
+                                            KindGuard.IsObject(type) ? (0, index_1.CreateType)(FromObject(moduleProperties, type.properties), type) :
+                                                KindGuard.IsRecord(type) ? (0, index_1.CreateType)(FromRecord(moduleProperties, type)) :
+                                                    KindGuard.IsTuple(type) ? (0, index_1.CreateType)(FromTuple(moduleProperties, type.items || []), type) :
+                                                        KindGuard.IsUnion(type) ? (0, index_1.CreateType)(FromUnion(moduleProperties, type.anyOf), type) :
+                                                            type);
+}
+// prettier-ignore
+function ComputeType(moduleProperties, key) {
+    return (key in moduleProperties
+        ? FromType(moduleProperties, moduleProperties[key])
+        : (0, index_16.Never)());
+}
+// prettier-ignore
+function ComputeModuleProperties(moduleProperties) {
+    return globalThis.Object.getOwnPropertyNames(moduleProperties).reduce((result, key) => {
+        return { ...result, [key]: ComputeType(moduleProperties, key) };
+    }, {});
+}

package/build/cjs/type/module/index.d.ts

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

package/build/cjs/type/module/index.js

@@ -0,0 +1,18 @@
+"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("./module"), exports);

package/build/cjs/type/module/infer.d.ts

@@ -0,0 +1,49 @@
+import { Ensure, Evaluate } from '../helpers/index';
+import { TSchema } from '../schema/index';
+import { TArray } from '../array/index';
+import { TAsyncIterator } from '../async-iterator/index';
+import { TConstructor } from '../constructor/index';
+import { TEnum, TEnumRecord } from '../enum/index';
+import { TFunction } from '../function/index';
+import { TIntersect } from '../intersect/index';
+import { TIterator } from '../iterator/index';
+import { TObject, TProperties } from '../object/index';
+import { TOptional } from '../optional/index';
+import { TRecord } from '../record/index';
+import { TReadonly } from '../readonly/index';
+import { TRef } from '../ref/index';
+import { TTuple } from '../tuple/index';
+import { TUnion } from '../union/index';
+import { Static } from '../static/index';
+import { TRecursive } from '../recursive/index';
+type TInferArray<ModuleProperties extends TProperties, Type extends TSchema> = (Ensure<Array<TInfer<ModuleProperties, Type>>>);
+type TInferAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (Ensure<AsyncIterableIterator<TInfer<ModuleProperties, Type>>>);
+type TInferConstructor<ModuleProperties extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema> = Ensure<new (...args: TInferTuple<ModuleProperties, Parameters>) => TInfer<ModuleProperties, InstanceType>>;
+type TInferFunction<ModuleProperties extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema> = Ensure<(...args: TInferTuple<ModuleProperties, Parameters>) => TInfer<ModuleProperties, ReturnType>>;
+type TInferIterator<ModuleProperties extends TProperties, Type extends TSchema> = (Ensure<IterableIterator<TInfer<ModuleProperties, Type>>>);
+type TInferIntersect<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = unknown> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TInferIntersect<ModuleProperties, Right, Result & TInfer<ModuleProperties, Left>> : Result);
+type ReadonlyOptionalPropertyKeys<Properties extends TProperties> = {
+    [Key in keyof Properties]: Properties[Key] extends TReadonly<TSchema> ? (Properties[Key] extends TOptional<Properties[Key]> ? Key : never) : never;
+}[keyof Properties];
+type ReadonlyPropertyKeys<Source extends TProperties> = {
+    [Key in keyof Source]: Source[Key] extends TReadonly<TSchema> ? (Source[Key] extends TOptional<Source[Key]> ? never : Key) : never;
+}[keyof Source];
+type OptionalPropertyKeys<Source extends TProperties> = {
+    [Key in keyof Source]: Source[Key] extends TOptional<TSchema> ? (Source[Key] extends TReadonly<Source[Key]> ? never : Key) : never;
+}[keyof Source];
+type RequiredPropertyKeys<Source extends TProperties> = keyof Omit<Source, ReadonlyOptionalPropertyKeys<Source> | ReadonlyPropertyKeys<Source> | OptionalPropertyKeys<Source>>;
+type InferPropertiesWithModifiers<Properties extends TProperties, Source extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<Source, ReadonlyOptionalPropertyKeys<Properties>>>> & Readonly<Pick<Source, ReadonlyPropertyKeys<Properties>>> & Partial<Pick<Source, OptionalPropertyKeys<Properties>>> & Required<Pick<Source, RequiredPropertyKeys<Properties>>>)>;
+type InferProperties<ModuleProperties extends TProperties, Properties extends TProperties> = InferPropertiesWithModifiers<Properties, {
+    [K in keyof Properties]: TInfer<ModuleProperties, Properties[K]>;
+}>;
+type TInferObject<ModuleProperties extends TProperties, Properties extends TProperties> = (InferProperties<ModuleProperties, Properties>);
+type TInferTuple<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TInferTuple<ModuleProperties, R, [...Result, TInfer<ModuleProperties, L>]> : Result);
+type TInferRecord<ModuleProperties extends TProperties, Key extends TSchema, Type extends TSchema, InferredKey extends PropertyKey = TInfer<ModuleProperties, Key> extends infer Key extends PropertyKey ? Key : never, InferedType extends unknown = TInfer<ModuleProperties, Type>> = Ensure<{
+    [_ in InferredKey]: InferedType;
+}>;
+type TInferRef<ModuleProperties extends TProperties, Ref extends string> = (Ref extends keyof ModuleProperties ? TInfer<ModuleProperties, ModuleProperties[Ref]> : unknown);
+type TInferUnion<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = never> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TInferUnion<ModuleProperties, R, Result | TInfer<ModuleProperties, L>> : Result);
+type TInfer<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TInferArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TInferAsyncIterator<ModuleProperties, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TInferConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TInferFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TInferIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TInferIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TInferObject<ModuleProperties, Properties> : Type extends TRecord<infer Key extends TSchema, infer Type extends TSchema> ? TInferRecord<ModuleProperties, Key, Type> : Type extends TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Static<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> : Type extends TRecursive<infer Schema extends TSchema> ? TInfer<ModuleProperties, Schema> : Static<Type>);
+/** Inference Path for Imports. This type is used to compute TImport `static` */
+export type TInferFromModuleKey<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TInfer<ModuleProperties, ModuleProperties[Key]> : never);
+export {};

package/build/cjs/type/module/infer.js

@@ -0,0 +1,3 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/type/module/module.d.ts

@@ -0,0 +1,27 @@
+import { Kind } from '../symbols/index';
+import { SchemaOptions, TSchema } from '../schema/index';
+import { TProperties } from '../object/index';
+import { Static } from '../static/index';
+import { TComputeModuleProperties } from './compute';
+import { TInferFromModuleKey } from './infer';
+export interface TDefinitions<ModuleProperties extends TProperties> extends TSchema {
+    static: {
+        [K in keyof ModuleProperties]: Static<ModuleProperties[K]>;
+    };
+    $defs: ModuleProperties;
+}
+export interface TImport<ModuleProperties extends TProperties = {}, Key extends keyof ModuleProperties = keyof ModuleProperties> extends TSchema {
+    [Kind]: 'Import';
+    static: TInferFromModuleKey<ModuleProperties, Key>;
+    $defs: ModuleProperties;
+    $ref: Key;
+}
+export declare class TModule<ModuleProperties extends TProperties, ComputedModuleProperties extends TProperties = TComputeModuleProperties<ModuleProperties>> {
+    private readonly $defs;
+    constructor($defs: ModuleProperties);
+    /** `[Json]` Imports a Type by Key. */
+    Import<Key extends keyof ComputedModuleProperties>(key: Key, options?: SchemaOptions): TImport<ComputedModuleProperties, Key>;
+    private WithIdentifiers;
+}
+/** `[Json]` Creates a Type Definition Module. */
+export declare function Module<Properties extends TProperties>(properties: Properties): TModule<Properties>;

package/build/cjs/type/module/module.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TModule = void 0;
+exports.Module = Module;
+const index_1 = require("../create/index");
+const index_2 = require("../symbols/index");
+// ------------------------------------------------------------------
+// Module Infrastructure Types
+// ------------------------------------------------------------------
+const compute_1 = require("./compute");
+// ------------------------------------------------------------------
+// Module
+// ------------------------------------------------------------------
+// prettier-ignore
+class TModule {
+    constructor($defs) {
+        const computed = (0, compute_1.ComputeModuleProperties)($defs);
+        const identified = this.WithIdentifiers(computed);
+        this.$defs = identified;
+    }
+    /** `[Json]` Imports a Type by Key. */
+    Import(key, options) {
+        const $defs = { ...this.$defs, [key]: (0, index_1.CreateType)(this.$defs[key], options) };
+        return (0, index_1.CreateType)({ [index_2.Kind]: 'Import', $defs, $ref: key });
+    }
+    // prettier-ignore
+    WithIdentifiers($defs) {
+        return globalThis.Object.getOwnPropertyNames($defs).reduce((result, key) => {
+            return { ...result, [key]: { ...$defs[key], $id: key } };
+        }, {});
+    }
+}
+exports.TModule = TModule;
+/** `[Json]` Creates a Type Definition Module. */
+function Module(properties) {
+    return new TModule(properties);
+}

package/build/cjs/type/never/index.d.ts

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

package/build/cjs/type/never/index.js

@@ -0,0 +1,18 @@
+"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("./never"), exports);

package/build/cjs/type/never/never.d.ts

@@ -0,0 +1,9 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface TNever extends TSchema {
+    [Kind]: 'Never';
+    static: never;
+    not: {};
+}
+/** `[Json]` Creates a Never type */
+export declare function Never(options?: SchemaOptions): TNever;

package/build/cjs/type/never/never.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Never = Never;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+/** `[Json]` Creates a Never type */
+function Never(options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Never', not: {} }, options);
+}

package/build/cjs/type/not/index.d.ts

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

package/build/cjs/type/not/index.js

@@ -0,0 +1,18 @@
+"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("./not"), exports);

package/build/cjs/type/not/not.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 TNot<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Not';
+    static: T extends TNot<infer U> ? Static<U> : unknown;
+    not: T;
+}
+/** `[Json]` Creates a Not type */
+export declare function Not<Type extends TSchema>(type: Type, options?: SchemaOptions): TNot<Type>;

package/build/cjs/type/not/not.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Not = Not;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+/** `[Json]` Creates a Not type */
+function Not(type, options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Not', not: type }, options);
+}

package/build/cjs/type/null/index.d.ts

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

package/build/cjs/type/null/index.js

@@ -0,0 +1,18 @@
+"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("./null"), exports);