tsondb 0.3.0 → 0.4.0

package/lib/node/schema/types/Type.d.ts

@@ -0,0 +1,48 @@
+import type { Decl } from "../declarations/Declaration.js";
+import type { BaseNode, GetReferences, Serializer } from "../Node.js";
+import type { Validator } from "../validation/type.js";
+import type { ArrayType, SerializedArrayType } from "./generic/ArrayType.js";
+import type { EnumType, SerializedEnumType } from "./generic/EnumType.js";
+import type { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "./generic/ObjectType.js";
+import type { BooleanType, SerializedBooleanType } from "./primitives/BooleanType.js";
+import type { DateType, SerializedDateType } from "./primitives/DateType.js";
+import type { FloatType, SerializedFloatType } from "./primitives/FloatType.js";
+import type { IntegerType, SerializedIntegerType } from "./primitives/IntegerType.js";
+import type { PrimitiveType, SerializedPrimitiveType } from "./primitives/PrimitiveType.js";
+import type { SerializedStringType, StringType } from "./primitives/StringType.js";
+import type { IncludeIdentifierType, SerializedIncludeIdentifierType } from "./references/IncludeIdentifierType.js";
+import type { NestedEntityMapType, SerializedNestedEntityMapType } from "./references/NestedEntityMapType.js";
+import type { ReferenceIdentifierType, SerializedReferenceIdentifierType } from "./references/ReferenceIdentifierType.js";
+import type { SerializedTypeArgumentType, TypeArgumentType } from "./references/TypeArgumentType.js";
+export interface BaseType extends BaseNode {
+    /**
+     * The parent node of this type will be set when the type is used in a declaration or nested in another type.
+     */
+    parent?: Type | Decl;
+}
+export interface SerializedBaseType extends BaseNode {
+}
+export type Type = PrimitiveType | ArrayType | ObjectType | TypeArgumentType | ReferenceIdentifierType | IncludeIdentifierType | NestedEntityMapType | EnumType;
+export type SerializedType = SerializedPrimitiveType | SerializedArrayType | SerializedObjectType | SerializedTypeArgumentType | SerializedReferenceIdentifierType | SerializedIncludeIdentifierType | SerializedNestedEntityMapType | SerializedEnumType;
+export declare const validate: Validator<Type>;
+export declare const resolveTypeArgumentsInType: (args: Record<string, Type>, type: Type) => Type;
+export declare function walkTypeNodeTree(callbackFn: (type: Type) => void, type: Type): void;
+export type AsType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? {
+    [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsType<P[K]["type"]> : AsType<P[K]["type"]> | undefined;
+} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType ? unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? unknown : never;
+export type SerializedAsType<T extends SerializedType> = T extends SerializedArrayType<infer I> ? SerializedAsType<I>[] : T extends SerializedObjectType<infer P> ? {
+    [K in keyof P]: P[K] extends SerializedMemberDecl<SerializedType, true> ? SerializedAsType<P[K]["type"]> : SerializedAsType<P[K]["type"]> | undefined;
+} : T extends SerializedBooleanType ? boolean : T extends SerializedDateType ? Date : T extends SerializedFloatType ? number : T extends SerializedIntegerType ? number : T extends SerializedStringType ? string : T extends SerializedTypeArgumentType ? unknown : T extends SerializedIncludeIdentifierType ? unknown : T extends SerializedNestedEntityMapType ? unknown : T extends SerializedReferenceIdentifierType ? unknown : never;
+export type AsNode<T> = T extends (infer I)[] ? ArrayType<AsNode<I>> : T extends Record<string, unknown> ? ObjectType<{
+    [K in keyof T]: T[K] extends MemberDecl ? T[K] : T extends null | undefined ? MemberDecl<AsNode<NonNullable<T[K]>>, false> : MemberDecl<AsNode<T[K]>, true>;
+}> : T extends string ? StringType : T extends number ? FloatType : T extends boolean ? BooleanType : never;
+export declare const getParentDecl: (type: Type) => Decl | undefined;
+export declare const findTypeAtPath: (type: Type, path: string[]) => Type | undefined;
+export declare const serializeType: Serializer<Type, SerializedType>;
+export declare const removeParentKey: <T extends BaseType>(type: T) => Omit<T, "parent">;
+export declare const getReferencesForType: GetReferences<Type>;
+/**
+ * Format the structure of a value to always look the same when serialized as JSON.
+ */
+export type StructureFormatter<T extends Type> = (type: T, value: unknown) => unknown;
+export declare const formatValue: StructureFormatter<Type>;

package/lib/{schema → node/schema}/types/Type.js

@@ -1,4 +1,4 @@
-import { assertExhaustive } from "../../shared/utils/typeSafety.js";
+import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { isDecl } from "../declarations/Declaration.js";
 import { NodeKind } from "../Node.js";
 import { formatArrayValue, getReferencesForArrayType, resolveTypeArgumentsInArrayType, serializeArrayType, validateArrayType, } from "./generic/ArrayType.js";
@@ -9,10 +9,10 @@ import { formatDateValue, getReferencesForDateType, serializeDateType, validateD
 import { formatFloatValue, getReferencesForFloatType, serializeFloatType, validateFloatType, } from "./primitives/FloatType.js";
 import { formatIntegerValue, getReferencesForIntegerType, serializeIntegerType, validateIntegerType, } from "./primitives/IntegerType.js";
 import { formatStringValue, getReferencesForStringType, serializeStringType, validateStringType, } from "./primitives/StringType.js";
-import { formatGenericArgumentIdentifierValue, getReferencesForGenericArgumentIdentifierType, resolveTypeArgumentsInGenericArgumentIdentifierType, serializeGenericArgumentIdentifierType, validateGenericArgumentIdentifierType, } from "./references/GenericArgumentIdentifierType.js";
 import { formatIncludeIdentifierValue, getReferencesForIncludeIdentifierType, resolveTypeArgumentsInIncludeIdentifierType, serializeIncludeIdentifierType, validateIncludeIdentifierType, } from "./references/IncludeIdentifierType.js";
 import { formatNestedEntityMapValue, getReferencesForNestedEntityMapType, resolveTypeArgumentsInNestedEntityMapType, serializeNestedEntityMapType, validateNestedEntityMapType, } from "./references/NestedEntityMapType.js";
 import { formatReferenceIdentifierValue, getReferencesForReferenceIdentifierType, resolveTypeArgumentsInReferenceIdentifierType, serializeReferenceIdentifierType, validateReferenceIdentifierType, } from "./references/ReferenceIdentifierType.js";
+import { formatTypeArgumentValue, getReferencesForTypeArgumentType, resolveTypeArgumentsInTypeArgumentType, serializeTypeArgumentType, validateTypeArgumentType, } from "./references/TypeArgumentType.js";
 export const validate = (helpers, type, value) => {
     switch (type.kind) {
         case NodeKind.ArrayType:
@@ -29,8 +29,8 @@ export const validate = (helpers, type, value) => {
             return validateIntegerType(helpers, type, value);
         case NodeKind.StringType:
             return validateStringType(helpers, type, value);
-        case NodeKind.GenericArgumentIdentifierType:
-            return validateGenericArgumentIdentifierType(helpers, type, value);
+        case NodeKind.TypeArgumentType:
+            return validateTypeArgumentType(helpers, type, value);
         case NodeKind.ReferenceIdentifierType:
             return validateReferenceIdentifierType(helpers, type, value);
         case NodeKind.IncludeIdentifierType:
@@ -55,8 +55,8 @@ export const resolveTypeArgumentsInType = (args, type) => {
         case NodeKind.IntegerType:
         case NodeKind.StringType:
             return type;
-        case NodeKind.GenericArgumentIdentifierType:
-            return resolveTypeArgumentsInGenericArgumentIdentifierType(args, type);
+        case NodeKind.TypeArgumentType:
+            return resolveTypeArgumentsInTypeArgumentType(args, type);
         case NodeKind.ReferenceIdentifierType:
             return resolveTypeArgumentsInReferenceIdentifierType(args, type);
         case NodeKind.IncludeIdentifierType:
@@ -73,29 +73,45 @@ export function walkTypeNodeTree(callbackFn, type) {
     switch (type.kind) {
         case NodeKind.ArrayType:
             callbackFn(type);
-            return walkTypeNodeTree(callbackFn, type.items);
+            {
+                walkTypeNodeTree(callbackFn, type.items);
+                return;
+            }
         case NodeKind.ObjectType:
             callbackFn(type);
-            return Object.values(type.properties).forEach(prop => walkTypeNodeTree(callbackFn, prop.type));
+            {
+                Object.values(type.properties).forEach(prop => {
+                    walkTypeNodeTree(callbackFn, prop.type);
+                });
+                return;
+            }
         case NodeKind.NestedEntityMapType:
             callbackFn(type);
-            return walkTypeNodeTree(callbackFn, type.type.value);
+            {
+                walkTypeNodeTree(callbackFn, type.type.value);
+                return;
+            }
         case NodeKind.BooleanType:
         case NodeKind.DateType:
         case NodeKind.FloatType:
         case NodeKind.IntegerType:
         case NodeKind.StringType:
-        case NodeKind.GenericArgumentIdentifierType:
+        case NodeKind.TypeArgumentType:
         case NodeKind.ReferenceIdentifierType:
-        case NodeKind.IncludeIdentifierType:
-            return callbackFn(type);
+        case NodeKind.IncludeIdentifierType: {
+            callbackFn(type);
+            return;
+        }
         case NodeKind.EnumType:
             callbackFn(type);
-            return Object.values(type.values).forEach(value => {
-                if (value.type) {
-                    walkTypeNodeTree(callbackFn, value.type);
-                }
-            });
+            {
+                Object.values(type.values).forEach(value => {
+                    if (value.type) {
+                        walkTypeNodeTree(callbackFn, value.type);
+                    }
+                });
+                return;
+            }
         default:
             return assertExhaustive(type);
     }
@@ -112,10 +128,10 @@ export const getParentDecl = (type) => {
     }
 };
 export const findTypeAtPath = (type, path) => {
-    if (path.length === 0) {
+    const [head, ...tail] = path;
+    if (head === undefined) {
         return type;
     }
-    const [head, ...tail] = path;
     if (type.kind === NodeKind.ObjectType) {
         const prop = type.properties[head];
         if (prop) {
@@ -143,8 +159,8 @@ export const serializeType = type => {
             return serializeIntegerType(type);
         case NodeKind.StringType:
             return serializeStringType(type);
-        case NodeKind.GenericArgumentIdentifierType:
-            return serializeGenericArgumentIdentifierType(type);
+        case NodeKind.TypeArgumentType:
+            return serializeTypeArgumentType(type);
         case NodeKind.ReferenceIdentifierType:
             return serializeReferenceIdentifierType(type);
         case NodeKind.IncludeIdentifierType:
@@ -177,8 +193,8 @@ export const getReferencesForType = (type, value) => {
             return getReferencesForIntegerType(type, value);
         case NodeKind.StringType:
             return getReferencesForStringType(type, value);
-        case NodeKind.GenericArgumentIdentifierType:
-            return getReferencesForGenericArgumentIdentifierType(type, value);
+        case NodeKind.TypeArgumentType:
+            return getReferencesForTypeArgumentType(type, value);
         case NodeKind.ReferenceIdentifierType:
             return getReferencesForReferenceIdentifierType(type, value);
         case NodeKind.IncludeIdentifierType:
@@ -207,8 +223,8 @@ export const formatValue = (type, value) => {
             return formatIntegerValue(type, value);
         case NodeKind.StringType:
             return formatStringValue(type, value);
-        case NodeKind.GenericArgumentIdentifierType:
-            return formatGenericArgumentIdentifierValue(type, value);
+        case NodeKind.TypeArgumentType:
+            return formatTypeArgumentValue(type, value);
         case NodeKind.IncludeIdentifierType:
             return formatIncludeIdentifierValue(type, value);
         case NodeKind.NestedEntityMapType:

package/lib/{schema → node/schema}/types/generic/ArrayType.d.ts

@@ -1,7 +1,8 @@
-import { GetNestedDeclarations } from "../../declarations/Declaration.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
+import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
 export interface ArrayType<T extends Type = Type> extends BaseType {
     kind: NodeKind["ArrayType"];
     minItems?: number;

package/lib/{schema → node/schema}/types/generic/ArrayType.js

@@ -1,5 +1,5 @@
-import { parallelizeErrors } from "../../../shared/utils/validation.js";
-import { validateArrayConstraints } from "../../../shared/validation/array.js";
+import { parallelizeErrors } from "../../../../shared/utils/validation.js";
+import { validateArrayConstraints } from "../../../../shared/validation/array.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
 import { getNestedDeclarations } from "../../declarations/Declaration.js";
 import { NodeKind } from "../../Node.js";
@@ -25,7 +25,7 @@ export const validateArrayType = (helpers, type, value) => {
     }
     return parallelizeErrors([
         ...validateArrayConstraints(type, value),
-        ...value.map((item, index) => wrapErrorsIfAny(`at index ${index}`, validate(helpers, type.items, item))),
+        ...value.map((item, index) => wrapErrorsIfAny(`at index ${index.toString()}`, validate(helpers, type.items, item))),
     ]);
 };
 export const resolveTypeArgumentsInArrayType = (args, type) => ArrayType(resolveTypeArgumentsInType(args, type.items), {

package/lib/{schema → node/schema}/types/generic/EnumType.d.ts

@@ -1,7 +1,8 @@
-import { GetNestedDeclarations } from "../../declarations/Declaration.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
+import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
 export interface EnumType<T extends Record<string, EnumCaseDecl> = Record<string, EnumCaseDecl>> extends BaseType {
     kind: NodeKind["EnumType"];
     values: T;

package/lib/{schema → node/schema}/types/generic/EnumType.js

@@ -1,4 +1,4 @@
-import { discriminatorKey } from "../../../shared/enum.js";
+import { discriminatorKey } from "../../../../shared/enum.js";
 import { getNestedDeclarations } from "../../declarations/Declaration.js";
 import { NodeKind } from "../../Node.js";
 import { formatValue, getReferencesForType, removeParentKey, resolveTypeArgumentsInType, serializeType, validate, } from "../Type.js";
@@ -74,7 +74,9 @@ export const getReferencesForEnumType = (type, value) => typeof value === "objec
     value[discriminatorKey] in type.values &&
     type.values[value[discriminatorKey]]?.type == null &&
     value[discriminatorKey] in value
-    ? getReferencesForType(type.values[value[discriminatorKey]].type, value[value[discriminatorKey]])
+    ? getReferencesForType(
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    type.values[value[discriminatorKey]].type, value[value[discriminatorKey]])
     : [];
 export const formatEnumType = (type, value) => {
     if (typeof value === "object" &&

package/lib/{schema → node/schema}/types/generic/ObjectType.d.ts

@@ -1,14 +1,15 @@
-import { ObjectConstraints } from "../../../shared/validation/object.js";
-import { GetNestedDeclarations } from "../../declarations/Declaration.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
-type TConstraint = Record<string, MemberDecl<Type, boolean>>;
+import type { ObjectConstraints } from "../../../../shared/validation/object.js";
+import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
+type TConstraint = Record<string, MemberDecl>;
 export interface ObjectType<T extends TConstraint = TConstraint> extends BaseType, ObjectConstraints {
     kind: NodeKind["ObjectType"];
     properties: T;
 }
-type TSerializedConstraint = Record<string, SerializedMemberDecl<SerializedType, boolean>>;
+type TSerializedConstraint = Record<string, SerializedMemberDecl>;
 export interface SerializedObjectType<T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType, ObjectConstraints {
     kind: NodeKind["ObjectType"];
     properties: T;

package/lib/{schema → node/schema}/types/generic/ObjectType.js

@@ -1,6 +1,6 @@
-import { sortObjectKeys } from "../../../shared/utils/object.js";
-import { parallelizeErrors } from "../../../shared/utils/validation.js";
-import { validateObjectConstraints } from "../../../shared/validation/object.js";
+import { sortObjectKeys } from "../../../../shared/utils/object.js";
+import { parallelizeErrors } from "../../../../shared/utils/validation.js";
+import { validateObjectConstraints } from "../../../../shared/validation/object.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
 import { getNestedDeclarations } from "../../declarations/Declaration.js";
 import { NodeKind } from "../../Node.js";
@@ -19,6 +19,7 @@ export const ObjectType = (properties, options = {}) => {
         if (!keyPattern.test(key)) {
             throw new TypeError(`Invalid object key "${key}". Object keys must not start with an underscore and may only contain letters, digits and underscores. (Pattern: ${keyPattern.source})`);
         }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         properties[key].type.parent = type;
     });
     return type;
@@ -34,6 +35,7 @@ export const validateObjectType = (helpers, type, value) => {
     return parallelizeErrors([
         ...validateObjectConstraints(type, expectedKeys, value),
         ...expectedKeys.map(key => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const prop = type.properties[key];
             if (prop.isRequired && !(key in value)) {
                 return TypeError(`missing required property "${key}"`);
@@ -68,7 +70,9 @@ export const serializeObjectType = type => ({
     ])),
 });
 export const getReferencesForObjectType = (type, value) => typeof value === "object" && value !== null
-    ? Object.entries(value).flatMap(([key, propValue]) => key in type.properties ? getReferencesForType(type.properties[key].type, propValue) : [])
+    ? Object.entries(value).flatMap(([key, propValue]) => 
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    key in type.properties ? getReferencesForType(type.properties[key].type, propValue) : [])
     : [];
 export const formatObjectValue = (type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
     ? sortObjectKeys(value, Object.keys(type.properties))

package/lib/{schema → node/schema}/types/primitives/BooleanType.d.ts

@@ -1,6 +1,7 @@
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface BooleanType extends BaseType {
     kind: NodeKind["BooleanType"];
 }

package/lib/{schema → node/schema}/types/primitives/DateType.d.ts

@@ -1,7 +1,8 @@
-import { DateConstraints } from "../../../shared/validation/date.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
+import type { DateConstraints } from "../../../../shared/validation/date.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface DateType extends BaseType, DateConstraints {
     kind: NodeKind["DateType"];
 }

package/lib/{schema → node/schema}/types/primitives/DateType.js

@@ -1,4 +1,4 @@
-import { validateDateConstraints } from "../../../shared/validation/date.js";
+import { validateDateConstraints } from "../../../../shared/validation/date.js";
 import { NodeKind } from "../../Node.js";
 import { removeParentKey } from "../Type.js";
 export const DateType = (options) => ({

package/lib/{schema → node/schema}/types/primitives/FloatType.d.ts

@@ -1,7 +1,8 @@
-import { RangeBound } from "../../../shared/validation/number.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
+import type { RangeBound } from "../../../../shared/validation/number.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface FloatType extends BaseType {
     kind: NodeKind["FloatType"];
     minimum?: RangeBound;

package/lib/{schema → node/schema}/types/primitives/FloatType.js

@@ -1,4 +1,4 @@
-import { validateNumberConstraints } from "../../../shared/validation/number.js";
+import { validateNumberConstraints } from "../../../../shared/validation/number.js";
 import { NodeKind } from "../../Node.js";
 import { removeParentKey } from "../Type.js";
 export const FloatType = (options = {}) => ({

package/lib/{schema → node/schema}/types/primitives/IntegerType.d.ts

@@ -1,7 +1,8 @@
-import { RangeBound } from "../../../shared/validation/number.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
+import type { RangeBound } from "../../../../shared/validation/number.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface IntegerType extends BaseType {
     kind: NodeKind["IntegerType"];
     minimum?: RangeBound;

package/lib/{schema → node/schema}/types/primitives/IntegerType.js

@@ -1,4 +1,4 @@
-import { validateNumberConstraints } from "../../../shared/validation/number.js";
+import { validateNumberConstraints } from "../../../../shared/validation/number.js";
 import { NodeKind } from "../../Node.js";
 import { validateOption } from "../../validation/options.js";
 import { removeParentKey } from "../Type.js";

package/lib/{schema → node/schema}/types/primitives/NumericType.d.ts

@@ -1,5 +1,5 @@
-import { FloatType, SerializedFloatType } from "./FloatType.js";
-import { IntegerType, SerializedIntegerType } from "./IntegerType.js";
+import type { FloatType, SerializedFloatType } from "./FloatType.js";
+import type { IntegerType, SerializedIntegerType } from "./IntegerType.js";
 export type NumericType = FloatType | IntegerType;
 export type SerializedNumericType = SerializedFloatType | SerializedIntegerType;
 export * from "./FloatType.js";

package/lib/node/schema/types/primitives/PrimitiveType.d.ts

@@ -0,0 +1,6 @@
+import type { BooleanType, SerializedBooleanType } from "./BooleanType.js";
+import type { DateType, SerializedDateType } from "./DateType.js";
+import type { NumericType, SerializedNumericType } from "./NumericType.js";
+import type { SerializedStringType, StringType } from "./StringType.js";
+export type PrimitiveType = BooleanType | DateType | NumericType | StringType;
+export type SerializedPrimitiveType = SerializedBooleanType | SerializedDateType | SerializedNumericType | SerializedStringType;

package/lib/{schema → node/schema}/types/primitives/StringType.d.ts

@@ -1,7 +1,8 @@
-import { StringConstraints } from "../../../shared/validation/string.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
+import type { StringConstraints } from "../../../../shared/validation/string.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface StringType extends BaseType, StringConstraints {
     kind: NodeKind["StringType"];
     pattern?: RegExp;

package/lib/{schema → node/schema}/types/primitives/StringType.js

@@ -1,4 +1,4 @@
-import { validateStringConstraints } from "../../../shared/validation/string.js";
+import { validateStringConstraints } from "../../../../shared/validation/string.js";
 import { NodeKind } from "../../Node.js";
 import { removeParentKey } from "../Type.js";
 export const StringType = (options = {}) => ({

package/lib/{schema → node/schema}/types/references/IncludeIdentifierType.d.ts

@@ -1,11 +1,12 @@
-import { GetNestedDeclarations, SerializedTypeArguments, TypeArguments } from "../../declarations/Declaration.js";
-import { EnumDecl } from "../../declarations/EnumDecl.js";
-import { TypeAliasDecl } from "../../declarations/TypeAliasDecl.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { SerializedTypeParameter, TypeParameter } from "../../parameters/TypeParameter.js";
-import { Validator } from "../../validation/type.js";
-import { EnumCaseDecl } from "../generic/EnumType.js";
-import { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
+import type { GetNestedDeclarations, SerializedTypeArguments, TypeArguments } from "../../declarations/Declaration.js";
+import type { EnumDecl } from "../../declarations/EnumDecl.js";
+import type { TypeAliasDecl } from "../../declarations/TypeAliasDecl.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { SerializedTypeParameter, TypeParameter } from "../../TypeParameter.js";
+import type { Validator } from "../../validation/type.js";
+import type { EnumCaseDecl } from "../generic/EnumType.js";
+import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
 type TConstraint<Params extends TypeParameter[]> = TypeAliasDecl<string, Type, Params> | EnumDecl<string, Record<string, EnumCaseDecl>, Params>;
 export interface IncludeIdentifierType<Params extends TypeParameter[] = TypeParameter[], T extends TConstraint<Params> = TConstraint<Params>> extends BaseType {
     kind: NodeKind["IncludeIdentifierType"];

package/lib/{schema → node/schema}/types/references/IncludeIdentifierType.js

@@ -1,7 +1,7 @@
 import { getNestedDeclarations, getReferencesForDecl, resolveTypeArgumentsInDecl, validateDecl, } from "../../declarations/Declaration.js";
 import { NodeKind } from "../../Node.js";
 import { formatEnumType } from "../generic/EnumType.js";
-import { formatValue, removeParentKey, resolveTypeArgumentsInType, serializeType, } from "../Type.js";
+import { formatValue, removeParentKey, resolveTypeArgumentsInType, serializeType } from "../Type.js";
 export const GenIncludeIdentifierType = (reference, args) => ({
     kind: NodeKind.IncludeIdentifierType,
     reference,

package/lib/{schema → node/schema}/types/references/NestedEntityMapType.d.ts

@@ -1,11 +1,12 @@
-import { Lazy } from "../../../utils/lazy.js";
-import { GetNestedDeclarations } from "../../declarations/Declaration.js";
-import { EntityDecl } from "../../declarations/EntityDecl.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "../generic/ObjectType.js";
-import { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
-type TConstraint = Record<string, MemberDecl<Type, boolean>>;
+import { Lazy } from "../../../../shared/utils/lazy.js";
+import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
+import type { EntityDecl } from "../../declarations/EntityDecl.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "../generic/ObjectType.js";
+import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
+type TConstraint = Record<string, MemberDecl>;
 export interface NestedEntityMapType<Name extends string = string, T extends TConstraint = TConstraint> extends BaseType {
     kind: NodeKind["NestedEntityMapType"];
     name: Name;
@@ -13,7 +14,7 @@ export interface NestedEntityMapType<Name extends string = string, T extends TCo
     secondaryEntity: EntityDecl;
     type: Lazy<ObjectType<T>>;
 }
-type TSerializedConstraint = Record<string, SerializedMemberDecl<SerializedType, boolean>>;
+type TSerializedConstraint = Record<string, SerializedMemberDecl>;
 export interface SerializedNestedEntityMapType<Name extends string = string, T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
     kind: NodeKind["NestedEntityMapType"];
     name: Name;

package/lib/{schema → node/schema}/types/references/NestedEntityMapType.js

@@ -1,10 +1,10 @@
-import { sortObjectKeysAlphabetically } from "../../../shared/utils/object.js";
-import { parallelizeErrors } from "../../../shared/utils/validation.js";
+import { Lazy } from "../../../../shared/utils/lazy.js";
+import { sortObjectKeysAlphabetically } from "../../../../shared/utils/object.js";
+import { parallelizeErrors } from "../../../../shared/utils/validation.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
-import { Lazy } from "../../../utils/lazy.js";
 import { NodeKind } from "../../Node.js";
 import { getNestedDeclarationsInObjectType, getReferencesForObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, validateObjectType, } from "../generic/ObjectType.js";
-import { removeParentKey, } from "../Type.js";
+import { removeParentKey } from "../Type.js";
 export const NestedEntityMapType = (options) => {
     const nestedEntityMapType = {
         ...options,

package/lib/{schema → node/schema}/types/references/ReferenceIdentifierType.d.ts

@@ -1,8 +1,9 @@
-import { GetNestedDeclarations } from "../../declarations/Declaration.js";
-import { EntityDecl } from "../../declarations/EntityDecl.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
+import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
+import type { EntityDecl } from "../../declarations/EntityDecl.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
 export interface ReferenceIdentifierType extends BaseType {
     kind: NodeKind["ReferenceIdentifierType"];
     entity: EntityDecl;
@@ -16,7 +17,7 @@ export { ReferenceIdentifierType as ReferenceIdentifier };
 export declare const isReferenceIdentifierType: (node: Node) => node is ReferenceIdentifierType;
 export declare const getNestedDeclarationsInReferenceIdentifierType: GetNestedDeclarations<ReferenceIdentifierType>;
 export declare const validateReferenceIdentifierType: Validator<ReferenceIdentifierType>;
-export declare const resolveTypeArgumentsInReferenceIdentifierType: <Args extends Record<string, Type>>(_args: Args, type: ReferenceIdentifierType) => ReferenceIdentifierType;
+export declare const resolveTypeArgumentsInReferenceIdentifierType: (_args: Record<string, Type>, type: ReferenceIdentifierType) => ReferenceIdentifierType;
 export declare const serializeReferenceIdentifierType: Serializer<ReferenceIdentifierType, SerializedReferenceIdentifierType>;
 export declare const getReferencesForReferenceIdentifierType: GetReferences<ReferenceIdentifierType>;
 export declare const formatReferenceIdentifierValue: StructureFormatter<ReferenceIdentifierType>;

package/lib/{schema → node/schema}/types/references/ReferenceIdentifierType.js

@@ -1,7 +1,7 @@
 import { getNestedDeclarations } from "../../declarations/Declaration.js";
 import { createEntityIdentifierType } from "../../declarations/EntityDecl.js";
 import { NodeKind } from "../../Node.js";
-import { removeParentKey, validate, } from "../Type.js";
+import { removeParentKey, validate } from "../Type.js";
 export const ReferenceIdentifierType = (entity) => ({
     kind: NodeKind.ReferenceIdentifierType,
     entity,

package/lib/node/schema/types/references/TypeArgumentType.d.ts

@@ -0,0 +1,23 @@
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { SerializedTypeParameter, TypeParameter } from "../../TypeParameter.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
+type TConstraint = TypeParameter;
+export interface TypeArgumentType<T extends TConstraint = TConstraint> extends BaseType {
+    kind: NodeKind["TypeArgumentType"];
+    argument: T;
+}
+type TSerializedConstraint = SerializedTypeParameter;
+export interface SerializedTypeArgumentType<T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
+    kind: NodeKind["TypeArgumentType"];
+    argument: T;
+}
+export declare const TypeArgumentType: <T extends TConstraint>(argument: T) => TypeArgumentType<T>;
+export { TypeArgumentType as TypeArgument };
+export declare const isTypeArgumentType: (node: Node) => node is TypeArgumentType;
+export declare const validateTypeArgumentType: Validator<TypeArgumentType>;
+export declare const resolveTypeArgumentsInTypeArgumentType: <T extends TConstraint, Args extends Record<string, Type>>(args: Args, type: TypeArgumentType<T>) => Args[T["name"]];
+export declare const serializeTypeArgumentType: Serializer<TypeArgumentType, SerializedTypeArgumentType>;
+export declare const getReferencesForTypeArgumentType: GetReferences<TypeArgumentType>;
+export declare const formatTypeArgumentValue: StructureFormatter<TypeArgumentType>;

package/lib/node/schema/types/references/TypeArgumentType.js

@@ -0,0 +1,19 @@
+import { NodeKind } from "../../Node.js";
+import { serializeTypeParameter } from "../../TypeParameter.js";
+import { removeParentKey } from "../Type.js";
+export const TypeArgumentType = (argument) => ({
+    kind: NodeKind.TypeArgumentType,
+    argument,
+});
+export { TypeArgumentType as TypeArgument };
+export const isTypeArgumentType = (node) => node.kind === NodeKind.TypeArgumentType;
+export const validateTypeArgumentType = (_helpers, type, _value) => {
+    throw new TypeError(`generic argument "${type.argument.name}" has not been replaced with a concrete type`);
+};
+export const resolveTypeArgumentsInTypeArgumentType = (args, type) => args[type.argument.name];
+export const serializeTypeArgumentType = type => ({
+    ...removeParentKey(type),
+    argument: serializeTypeParameter(type.argument),
+});
+export const getReferencesForTypeArgumentType = (_type, _value) => [];
+export const formatTypeArgumentValue = (_type, value) => value;

package/lib/node/schema/validation/type.d.ts

@@ -0,0 +1,4 @@
+import type { Validators } from "../Node.js";
+import type { Type } from "../types/Type.js";
+export type ValidatorHelpers = Validators;
+export type Validator<T extends Type, Args extends unknown[] = []> = (helpers: ValidatorHelpers, type: T, value: unknown, ...args: Args) => Error[];