@sinclair/typebox 0.33.22 → 0.34.1

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

@@ -4,13 +4,18 @@ import type { TMappedResult } from '../mapped/index';
 import type { SchemaOptions } from '../schema/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TNumber } from '../number/index';
+import { TComputed } from '../computed/index';
+import { type TRef } from '../ref/index';
 import { type TKeyOfPropertyKeys } from './keyof-property-keys';
 import { type TUnionEvaluated } from '../union/index';
 import { type TKeyOfFromMappedResult } from './keyof-from-mapped-result';
-export type TKeyOfPropertyKeysToRest<T extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? L extends '[number]' ? TKeyOfPropertyKeysToRest<R, [...Acc, TNumber]> : TKeyOfPropertyKeysToRest<R, [...Acc, TLiteral<Assert<L, TLiteralValue>>]> : Acc);
-export declare function KeyOfPropertyKeysToRest<T extends PropertyKey[]>(T: [...T]): TKeyOfPropertyKeysToRest<T>;
-export type TKeyOf<T extends TSchema, K extends PropertyKey[] = TKeyOfPropertyKeys<T>, S extends TSchema[] = TKeyOfPropertyKeysToRest<K>, U = TUnionEvaluated<S>> = (Ensure<U>);
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<TComputed<'KeyOf', [TComputed<Target, Parameters>]>>;
+type TFromRef<Ref extends string> = Ensure<TComputed<'KeyOf', [TRef<Ref>]>>;
+/** `[Internal]` Used by KeyOfFromMappedResult */
+export type TKeyOfFromType<Type extends TSchema, PropertyKeys extends PropertyKey[] = TKeyOfPropertyKeys<Type>, PropertyKeyTypes extends TSchema[] = TKeyOfPropertyKeysToRest<PropertyKeys>, Result = TUnionEvaluated<PropertyKeyTypes>> = Ensure<Result>;
+export type TKeyOfPropertyKeysToRest<PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = (PropertyKeys extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? L extends '[number]' ? TKeyOfPropertyKeysToRest<R, [...Result, TNumber]> : TKeyOfPropertyKeysToRest<R, [...Result, TLiteral<Assert<L, TLiteralValue>>]> : Result);
+export declare function KeyOfPropertyKeysToRest<PropertyKeys extends PropertyKey[]>(propertyKeys: [...PropertyKeys]): TKeyOfPropertyKeysToRest<PropertyKeys>;
+export type TKeyOf<Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TMappedResult ? TKeyOfFromMappedResult<Type> : TKeyOfFromType<Type>);
 /** `[Json]` Creates a KeyOf type */
-export declare function KeyOf<T extends TMappedResult>(T: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
-/** `[Json]` Creates a KeyOf type */
-export declare function KeyOf<T extends TSchema>(T: T, options?: SchemaOptions): TKeyOf<T>;
+export declare function KeyOf<Type extends TSchema>(type: Type, options?: SchemaOptions): TKeyOf<Type>;
+export {};

package/build/cjs/type/keyof/keyof.js

@@ -6,26 +6,35 @@ exports.KeyOf = KeyOf;
 const type_1 = require("../create/type");
 const index_1 = require("../literal/index");
 const index_2 = require("../number/index");
+const index_3 = require("../computed/index");
+const index_4 = require("../ref/index");
 const keyof_property_keys_1 = require("./keyof-property-keys");
-const index_3 = require("../union/index");
+const index_5 = require("../union/index");
 const keyof_from_mapped_result_1 = require("./keyof-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
-function KeyOfPropertyKeysToRest(T) {
-    return T.map(L => L === '[number]' ? (0, index_2.Number)() : (0, index_1.Literal)(L));
+function FromComputed(target, parameters) {
+    return (0, index_3.Computed)('KeyOf', [(0, index_3.Computed)(target, parameters)]);
+}
+// prettier-ignore
+function FromRef($ref) {
+    return (0, index_3.Computed)('KeyOf', [(0, index_4.Ref)($ref)]);
+}
+// prettier-ignore
+function KeyOfFromType(type, options) {
+    const propertyKeys = (0, keyof_property_keys_1.KeyOfPropertyKeys)(type);
+    const propertyKeyTypes = KeyOfPropertyKeysToRest(propertyKeys);
+    const result = (0, index_5.UnionEvaluated)(propertyKeyTypes);
+    return (0, type_1.CreateType)(result, options);
+}
+// prettier-ignore
+function KeyOfPropertyKeysToRest(propertyKeys) {
+    return propertyKeys.map(L => L === '[number]' ? (0, index_2.Number)() : (0, index_1.Literal)(L));
 }
 /** `[Json]` Creates a KeyOf type */
-function KeyOf(T, options) {
-    if ((0, kind_1.IsMappedResult)(T)) {
-        return (0, keyof_from_mapped_result_1.KeyOfFromMappedResult)(T, options);
-    }
-    else {
-        const K = (0, keyof_property_keys_1.KeyOfPropertyKeys)(T);
-        const S = KeyOfPropertyKeysToRest(K);
-        const U = (0, index_3.UnionEvaluated)(S);
-        return (0, type_1.CreateType)(U, options);
-    }
+function KeyOf(type, options) {
+    return ((0, kind_1.IsComputed)(type) ? FromComputed(type.target, type.parameters) : (0, kind_1.IsRef)(type) ? FromRef(type.$ref) : (0, kind_1.IsMappedResult)(type) ? (0, keyof_from_mapped_result_1.KeyOfFromMappedResult)(type, options) : KeyOfFromType(type, options));
 }

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

@@ -0,0 +1,54 @@
+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 } from '../indexed/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 TPick } from '../pick/index';
+import { type TNever } from '../never/index';
+import { TPartial } from '../partial/index';
+import { type TRecordOrObject } from '../record/index';
+import { type TRef } from '../ref/index';
+import { TRequired } from '../required/index';
+import { type TTuple } from '../tuple/index';
+import { type TUnion, type TUnionEvaluated } from '../union/index';
+type TDerefParameters<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> ? TDerefParameters<ModuleProperties, Right, [...Result, TDeref<ModuleProperties, Key>]> : TDerefParameters<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]> : Result);
+type TDeref<ModuleProperties extends TProperties, Ref extends string, Result extends TSchema = (Ref extends keyof ModuleProperties ? ModuleProperties[Ref] extends TRef<infer Ref2 extends string> ? TDeref<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, T1> : 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 TFromRecord<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TRecordOrObject<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[] = TDerefParameters<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 'Record' ? TFromRecord<Dereferenced> : Target extends 'Required' ? TFromRequired<Dereferenced> : TNever);
+type TFromObject<ModuleProperties extends TProperties, Properties extends TProperties> = Ensure<TObject<Evaluate<{
+    [Key in keyof Properties]: TFromType<ModuleProperties, Properties[Key]>;
+}>>>;
+type TFromConstructor<ModuleProperties extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema> = (TConstructor<TFromRest<ModuleProperties, Parameters>, TFromType<ModuleProperties, InstanceType>>);
+type TFromFunction<ModuleProperties extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema> = Ensure<Ensure<TFunction<TFromRest<ModuleProperties, Parameters>, TFromType<ModuleProperties, ReturnType>>>>;
+type TFromTuple<ModuleProperties extends TProperties, Types extends TSchema[]> = (Ensure<TTuple<TFromRest<ModuleProperties, Types>>>);
+type TFromIntersect<ModuleProperties extends TProperties, Types extends TSchema[]> = (Ensure<TIntersectEvaluated<TFromRest<ModuleProperties, Types>>>);
+type TFromUnion<ModuleProperties extends TProperties, Types extends TSchema[]> = (Ensure<TUnionEvaluated<TFromRest<ModuleProperties, Types>>>);
+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 TFromIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TIterator<TFromType<ModuleProperties, Type>>);
+type TFromRest<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]> : Result);
+export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TComputed<infer T extends string, infer S extends TSchema[]> ? TFromComputed<ModuleProperties, T, S> : Type extends TObject<infer S extends TProperties> ? TFromObject<ModuleProperties, S> : Type extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TFromConstructor<ModuleProperties, S, R> : Type extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFromFunction<ModuleProperties, S, R> : Type extends TTuple<infer S extends TSchema[]> ? TFromTuple<ModuleProperties, S> : Type extends TIntersect<infer S extends TSchema[]> ? TFromIntersect<ModuleProperties, S> : Type extends TUnion<infer S extends TSchema[]> ? TFromUnion<ModuleProperties, S> : Type extends TArray<infer S extends TSchema> ? TFromArray<ModuleProperties, S> : Type extends TAsyncIterator<infer S extends TSchema> ? TFromAsyncIterator<ModuleProperties, S> : Type extends TIterator<infer S extends TSchema> ? TFromIterator<ModuleProperties, S> : 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,154 @@
+"use strict";
+
+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("../array/index");
+const index_3 = require("../awaited/index");
+const index_4 = require("../async-iterator/index");
+const index_5 = require("../constructor/index");
+const index_6 = require("../indexed/index");
+const index_7 = require("../function/index");
+const index_8 = require("../intersect/index");
+const index_9 = require("../iterator/index");
+const index_10 = require("../keyof/index");
+const index_11 = require("../object/index");
+const index_12 = require("../omit/index");
+const index_13 = require("../pick/index");
+const index_14 = require("../never/index");
+const index_15 = require("../partial/index");
+const index_16 = require("../record/index");
+const index_17 = require("../required/index");
+const index_18 = require("../tuple/index");
+const index_19 = require("../union/index");
+// ------------------------------------------------------------------
+// KindGuard
+// ------------------------------------------------------------------
+const KindGuard = require("../guard/kind");
+// prettier-ignore
+function DerefParameters(moduleProperties, types) {
+    return types.map((type) => {
+        return KindGuard.IsRef(type)
+            ? Deref(moduleProperties, type.$ref)
+            : FromType(moduleProperties, type);
+    });
+}
+// prettier-ignore
+function Deref(moduleProperties, ref) {
+    return (ref in moduleProperties
+        ? KindGuard.IsRef(moduleProperties[ref])
+            ? Deref(moduleProperties, moduleProperties[ref].$ref)
+            : FromType(moduleProperties, moduleProperties[ref])
+        : (0, index_14.Never)());
+}
+// prettier-ignore
+function FromAwaited(parameters) {
+    return (0, index_3.Awaited)(parameters[0]);
+}
+// prettier-ignore
+function FromIndex(parameters) {
+    return (0, index_6.Index)(parameters[0], parameters[1]);
+}
+// prettier-ignore
+function FromKeyOf(parameters) {
+    return (0, index_10.KeyOf)(parameters[0]);
+}
+// prettier-ignore
+function FromPartial(parameters) {
+    return (0, index_15.Partial)(parameters[0]);
+}
+// prettier-ignore
+function FromOmit(parameters) {
+    return (0, index_12.Omit)(parameters[0], parameters[1]);
+}
+// prettier-ignore
+function FromPick(parameters) {
+    return (0, index_13.Pick)(parameters[0], parameters[1]);
+}
+// prettier-ignore
+function FromRecord(parameters) {
+    return (0, index_16.Record)(parameters[0], parameters[1]);
+}
+// prettier-ignore
+function FromRequired(parameters) {
+    return (0, index_17.Required)(parameters[0]);
+}
+// prettier-ignore
+function FromComputed(moduleProperties, target, parameters) {
+    const dereferenced = DerefParameters(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 === 'Record' ? FromRecord(dereferenced) :
+                                target === 'Required' ? FromRequired(dereferenced) :
+                                    (0, index_14.Never)());
+}
+function FromObject(moduleProperties, properties) {
+    return (0, index_11.Object)(globalThis.Object.keys(properties).reduce((result, key) => {
+        return { ...result, [key]: FromType(moduleProperties, properties[key]) };
+    }, {}));
+}
+// prettier-ignore
+function FromConstructor(moduleProperties, parameters, instanceType) {
+    return (0, index_5.Constructor)(FromRest(moduleProperties, parameters), FromType(moduleProperties, instanceType));
+}
+// prettier-ignore
+function FromFunction(moduleProperties, parameters, returnType) {
+    return (0, index_7.Function)(FromRest(moduleProperties, parameters), FromType(moduleProperties, returnType));
+}
+function FromTuple(moduleProperties, types) {
+    return (0, index_18.Tuple)(FromRest(moduleProperties, types));
+}
+function FromIntersect(moduleProperties, types) {
+    return (0, index_8.Intersect)(FromRest(moduleProperties, types));
+}
+function FromUnion(moduleProperties, types) {
+    return (0, index_19.Union)(FromRest(moduleProperties, types));
+}
+function FromArray(moduleProperties, type) {
+    return (0, index_2.Array)(FromType(moduleProperties, type));
+}
+function FromAsyncIterator(moduleProperties, type) {
+    return (0, index_4.AsyncIterator)(FromType(moduleProperties, type));
+}
+function FromIterator(moduleProperties, type) {
+    return (0, index_9.Iterator)(FromType(moduleProperties, type));
+}
+function FromRest(moduleProperties, types) {
+    return types.map((type) => FromType(moduleProperties, type));
+}
+// prettier-ignore
+function FromType(moduleProperties, type) {
+    return (
+    // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
+    // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
+    // be a priority as there is a potential for the current inference to break on TS compiler changes.
+    KindGuard.IsComputed(type) ? (0, index_1.CreateType)(FromComputed(moduleProperties, type.target, type.parameters)) :
+        KindGuard.IsObject(type) ? (0, index_1.CreateType)(FromObject(moduleProperties, type.properties), type) :
+            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.IsTuple(type) ? (0, index_1.CreateType)(FromTuple(moduleProperties, type.items || []), type) :
+                        KindGuard.IsIntersect(type) ? (0, index_1.CreateType)(FromIntersect(moduleProperties, type.allOf), type) :
+                            KindGuard.IsUnion(type) ? (0, index_1.CreateType)(FromUnion(moduleProperties, type.anyOf), type) :
+                                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.IsIterator(type) ? (0, index_1.CreateType)(FromIterator(moduleProperties, type.items), type) :
+                                            type);
+}
+// prettier-ignore
+function ComputeType(moduleProperties, key) {
+    return (key in moduleProperties
+        ? FromType(moduleProperties, moduleProperties[key])
+        : (0, index_14.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/{strict → module}/index.js

@@ -15,4 +15,4 @@ 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("./strict"), exports);
+__exportStar(require("./module"), exports);

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

@@ -0,0 +1,43 @@
+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 { 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 { TReadonly } from '../readonly/index';
+import { TRef } from '../ref/index';
+import { TTuple } from '../tuple/index';
+import { TUnion } from '../union/index';
+import { Static } from '../static/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 L extends TSchema, ...infer R extends TSchema[]] ? TInferIntersect<ModuleProperties, R, Result & TInfer<ModuleProperties, L>> : Result);
+type ReadonlyOptionalPropertyKeys<Properties extends TProperties> = {
+    [K in keyof Properties]: Properties[K] extends TReadonly<TSchema> ? (Properties[K] extends TOptional<Properties[K]> ? K : never) : never;
+}[keyof Properties];
+type ReadonlyPropertyKeys<Source extends TProperties> = {
+    [K in keyof Source]: Source[K] extends TReadonly<TSchema> ? (Source[K] extends TOptional<Source[K]> ? never : K) : never;
+}[keyof Source];
+type OptionalPropertyKeys<Source extends TProperties> = {
+    [K in keyof Source]: Source[K] extends TOptional<TSchema> ? (Source[K] extends TReadonly<Source[K]> ? never : K) : 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 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 TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> : 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,37 @@
+"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) {
+        return (0, index_1.CreateType)({ [index_2.Kind]: 'Import', $defs: this.$defs, $ref: key }, options);
+    }
+    // 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/not/not.d.ts

@@ -7,4 +7,4 @@ export interface TNot<T extends TSchema = TSchema> extends TSchema {
     not: T;
 }
 /** `[Json]` Creates a Not type */
-export declare function Not<T extends TSchema>(not: T, options?: SchemaOptions): TNot<T>;
+export declare function Not<Type extends TSchema>(type: Type, options?: SchemaOptions): TNot<Type>;

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

@@ -5,6 +5,6 @@ exports.Not = Not;
 const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[Json]` Creates a Not type */
-function Not(not, options) {
-    return (0, type_1.CreateType)({ [index_1.Kind]: 'Not', not }, options);
+function Not(type, options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Not', not: type }, options);
 }

package/build/cjs/type/omit/omit-from-mapped-key.d.ts

@@ -2,11 +2,11 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
 import { type TOmit } from './omit';
-type TFromPropertyKey<T extends TSchema, K extends PropertyKey> = {
-    [_ in K]: TOmit<T, [K]>;
+type TFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+    [_ in Key]: TOmit<Type, [Key]>;
 };
-type TFromPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? TFromPropertyKeys<T, RK, Acc & TFromPropertyKey<T, LK>> : Acc);
-type TFromMappedKey<T extends TSchema, K extends TMappedKey> = (TFromPropertyKeys<T, K['keys']>);
-export type TOmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>> = (TMappedResult<P>);
-export declare function OmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>>(T: T, K: K, options?: SchemaOptions): TMappedResult<P>;
+type TFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (PropertyKeys extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? TFromPropertyKeys<Type, RK, Result & TFromPropertyKey<Type, LK>> : Result);
+type TFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey> = (TFromPropertyKeys<Type, MappedKey['keys']>);
+export type TOmitFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TFromMappedKey<Type, MappedKey>> = (TMappedResult<Properties>);
+export declare function OmitFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TFromMappedKey<Type, MappedKey>>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedResult<Properties>;
 export {};

package/build/cjs/type/omit/omit-from-mapped-key.js

@@ -6,23 +6,21 @@ const index_1 = require("../mapped/index");
 const omit_1 = require("./omit");
 const value_1 = require("../clone/value");
 // prettier-ignore
-function FromPropertyKey(T, K, options) {
-    return {
-        [K]: (0, omit_1.Omit)(T, [K], (0, value_1.Clone)(options))
-    };
+function FromPropertyKey(type, key, options) {
+    return { [key]: (0, omit_1.Omit)(type, [key], (0, value_1.Clone)(options)) };
 }
 // prettier-ignore
-function FromPropertyKeys(T, K, options) {
-    return K.reduce((Acc, LK) => {
-        return { ...Acc, ...FromPropertyKey(T, LK, options) };
+function FromPropertyKeys(type, propertyKeys, options) {
+    return propertyKeys.reduce((Acc, LK) => {
+        return { ...Acc, ...FromPropertyKey(type, LK, options) };
     }, {});
 }
 // prettier-ignore
-function FromMappedKey(T, K, options) {
-    return FromPropertyKeys(T, K.keys, options);
+function FromMappedKey(type, mappedKey, options) {
+    return FromPropertyKeys(type, mappedKey.keys, options);
 }
 // prettier-ignore
-function OmitFromMappedKey(T, K, options) {
-    const P = FromMappedKey(T, K, options);
-    return (0, index_1.MappedResult)(P);
+function OmitFromMappedKey(type, mappedKey, options) {
+    const properties = FromMappedKey(type, mappedKey, options);
+    return (0, index_1.MappedResult)(properties);
 }

package/build/cjs/type/omit/omit-from-mapped-result.d.ts

@@ -3,10 +3,10 @@ import type { Ensure, Evaluate } from '../helpers/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TOmit } from './omit';
-type TFromProperties<P extends TProperties, K extends PropertyKey[]> = ({
-    [K2 in keyof P]: TOmit<P[K2], K>;
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = ({
+    [K2 in keyof Properties]: TOmit<Properties[K2], PropertyKeys>;
 });
-type TFromMappedResult<R extends TMappedResult, K extends PropertyKey[]> = (Evaluate<TFromProperties<R['properties'], K>>);
-export type TOmitFromMappedResult<T extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<T, K>> = (Ensure<TMappedResult<P>>);
-export declare function OmitFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options?: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[]> = (Evaluate<TFromProperties<MappedResult['properties'], PropertyKeys>>);
+export type TOmitFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[], Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>> = (Ensure<TMappedResult<Properties>>);
+export declare function OmitFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[], Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>>(mappedResult: MappedResult, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TMappedResult<Properties>;
 export {};

package/build/cjs/type/omit/omit-from-mapped-result.js

@@ -6,18 +6,18 @@ const index_1 = require("../mapped/index");
 const omit_1 = require("./omit");
 const value_1 = require("../clone/value");
 // prettier-ignore
-function FromProperties(P, K, options) {
-    const Acc = {};
-    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-        Acc[K2] = (0, omit_1.Omit)(P[K2], K, (0, value_1.Clone)(options));
-    return Acc;
+function FromProperties(properties, propertyKeys, options) {
+    const result = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+        result[K2] = (0, omit_1.Omit)(properties[K2], propertyKeys, (0, value_1.Clone)(options));
+    return result;
 }
 // prettier-ignore
-function FromMappedResult(R, K, options) {
-    return FromProperties(R.properties, K, options);
+function FromMappedResult(mappedResult, propertyKeys, options) {
+    return FromProperties(mappedResult.properties, propertyKeys, options);
 }
 // prettier-ignore
-function OmitFromMappedResult(R, K, options) {
-    const P = FromMappedResult(R, K, options);
-    return (0, index_1.MappedResult)(P);
+function OmitFromMappedResult(mappedResult, propertyKeys, options) {
+    const properties = FromMappedResult(mappedResult, propertyKeys, options);
+    return (0, index_1.MappedResult)(properties);
 }

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

@@ -2,23 +2,35 @@ import type { SchemaOptions, TSchema } from '../schema/index';
 import type { TupleToUnion, Evaluate, Ensure } from '../helpers/index';
 import { type TRecursive } from '../recursive/index';
 import type { TMappedKey, TMappedResult } from '../mapped/index';
+import { TComputed } from '../computed/index';
+import { TLiteral, TLiteralValue } from '../literal/index';
+import { type TIndexPropertyKeys } from '../indexed/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TObject, type TProperties } from '../object/index';
-import { type TIndexPropertyKeys } from '../indexed/index';
+import { type TRef } from '../ref/index';
 import { type TOmitFromMappedKey } from './omit-from-mapped-key';
 import { type TOmitFromMappedResult } from './omit-from-mapped-result';
-type TFromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, K, [...Acc, TOmit<L, K>]> : Acc);
-type TFromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, K, [...Acc, TOmit<L, K>]> : Acc);
-type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Omit<T, I>>;
-type TFromObject<T extends TObject, K extends PropertyKey[], Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties, K>)>>;
-export type TOmit<T extends TProperties, K extends PropertyKey[]> = (T extends TRecursive<infer S extends TSchema> ? TRecursive<TOmit<S, K>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromIntersect<S, K>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromUnion<S, K>> : T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>, K> : TObject<{}>);
-/** `[Json]` Constructs a type whose keys are omitted from the given type */
-export declare function Omit<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TOmitFromMappedResult<T, K>;
-/** `[Json]` Constructs a type whose keys are omitted from the given type */
-export declare function Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TOmitFromMappedKey<T, K>;
-/** `[Json]` Constructs a type whose keys are omitted from the given type */
-export declare function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
-/** `[Json]` Constructs a type whose keys are omitted from the given type */
-export declare function Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
+type TFromIntersect<Types extends TSchema[], PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, PropertyKeys, [...Result, TOmit<L, PropertyKeys>]> : Result);
+type TFromUnion<T extends TSchema[], K extends PropertyKey[], Result extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, K, [...Result, TOmit<L, K>]> : Result);
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[], UnionKey extends PropertyKey = TupleToUnion<PropertyKeys>> = (Evaluate<Omit<Properties, UnionKey>>);
+type TFromObject<Type extends TObject, PropertyKeys extends PropertyKey[], Properties extends TProperties = Type['properties']> = Ensure<TObject<(TFromProperties<Properties, PropertyKeys>)>>;
+type TUnionFromPropertyKeys<PropertyKeys extends PropertyKey[], Result extends TLiteral[] = []> = (PropertyKeys extends [infer Key extends PropertyKey, ...infer Rest extends PropertyKey[]] ? Key extends TLiteralValue ? TUnionFromPropertyKeys<Rest, [...Result, TLiteral<Key>]> : TUnionFromPropertyKeys<Rest, [...Result]> : TUnion<Result>);
+export type TOmitResolve<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = (Properties extends TRecursive<infer Types extends TSchema> ? TRecursive<TOmitResolve<Types, PropertyKeys>> : Properties extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromIntersect<Types, PropertyKeys>> : Properties extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromUnion<Types, PropertyKeys>> : Properties extends TObject<infer Types extends TProperties> ? TFromObject<TObject<Types>, PropertyKeys> : TObject<{}>);
+type TResolvePropertyKeys<Key extends TSchema | PropertyKey[]> = Key extends TSchema ? TIndexPropertyKeys<Key> : Key;
+type TResolveTypeKey<Key extends TSchema | PropertyKey[]> = Key extends PropertyKey[] ? TUnionFromPropertyKeys<Key> : Key;
+export type TOmit<Type extends TSchema, Key extends TSchema | PropertyKey[], IsTypeRef extends boolean = Type extends TRef ? true : false, IsKeyRef extends boolean = Key extends TRef ? true : false> = (Type extends TMappedResult ? TOmitFromMappedResult<Type, TResolvePropertyKeys<Key>> : Key extends TMappedKey ? TOmitFromMappedKey<Type, Key> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [true, true] ? TComputed<'Omit', [Type, TResolveTypeKey<Key>]> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [false, true] ? TComputed<'Omit', [Type, TResolveTypeKey<Key>]> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [true, false] ? TComputed<'Omit', [Type, TResolveTypeKey<Key>]> : TOmitResolve<Type, TResolvePropertyKeys<Key>>);
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export declare function Omit<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TOmit<Type, Key>;
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export declare function Omit<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TOmit<Type, Key>;
 export {};