tsondb 0.5.18 → 0.6.0

package/dist/src/node/schema/types/Type.js

@@ -1,91 +1,35 @@
 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";
-import { formatEnumType, getReferencesForEnumType, resolveTypeArgumentsInEnumType, serializeEnumType, validateEnumType, } from "./generic/EnumType.js";
-import { formatObjectValue, getReferencesForObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, validateObjectType, } from "./generic/ObjectType.js";
-import { formatBooleanValue, getReferencesForBooleanType, serializeBooleanType, validateBooleanType, } from "./primitives/BooleanType.js";
-import { formatDateValue, getReferencesForDateType, serializeDateType, validateDateType, } from "./primitives/DateType.js";
-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 { 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:
-            return validateArrayType(helpers, type, value);
-        case NodeKind.ObjectType:
-            return validateObjectType(helpers, type, value);
-        case NodeKind.BooleanType:
-            return validateBooleanType(helpers, type, value);
-        case NodeKind.DateType:
-            return validateDateType(helpers, type, value);
-        case NodeKind.FloatType:
-            return validateFloatType(helpers, type, value);
-        case NodeKind.IntegerType:
-            return validateIntegerType(helpers, type, value);
-        case NodeKind.StringType:
-            return validateStringType(helpers, type, value);
-        case NodeKind.TypeArgumentType:
-            return validateTypeArgumentType(helpers, type, value);
-        case NodeKind.ReferenceIdentifierType:
-            return validateReferenceIdentifierType(helpers, type, value);
-        case NodeKind.IncludeIdentifierType:
-            return validateIncludeIdentifierType(helpers, type, value);
-        case NodeKind.NestedEntityMapType:
-            return validateNestedEntityMapType(helpers, type, value);
-        case NodeKind.EnumType:
-            return validateEnumType(helpers, type, value);
-        default:
-            return assertExhaustive(type);
-    }
-};
-export const resolveTypeArgumentsInType = (args, type) => {
-    switch (type.kind) {
-        case NodeKind.ArrayType:
-            return resolveTypeArgumentsInArrayType(args, type);
-        case NodeKind.ObjectType:
-            return resolveTypeArgumentsInObjectType(args, type);
-        case NodeKind.BooleanType:
-        case NodeKind.DateType:
-        case NodeKind.FloatType:
-        case NodeKind.IntegerType:
-        case NodeKind.StringType:
-            return type;
-        case NodeKind.TypeArgumentType:
-            return resolveTypeArgumentsInTypeArgumentType(args, type);
-        case NodeKind.ReferenceIdentifierType:
-            return resolveTypeArgumentsInReferenceIdentifierType(args, type);
-        case NodeKind.IncludeIdentifierType:
-            return resolveTypeArgumentsInIncludeIdentifierType(args, type);
-        case NodeKind.NestedEntityMapType:
-            return resolveTypeArgumentsInNestedEntityMapType(args, type);
-        case NodeKind.EnumType:
-            return resolveTypeArgumentsInEnumType(args, type);
-        default:
-            return assertExhaustive(type);
-    }
-};
-export function walkTypeNodeTree(callbackFn, type) {
+import { formatArrayValue } from "./generic/ArrayType.js";
+import { formatEnumType } from "./generic/EnumType.js";
+import { formatObjectValue } from "./generic/ObjectType.js";
+import { formatBooleanValue } from "./primitives/BooleanType.js";
+import { formatDateValue } from "./primitives/DateType.js";
+import { formatFloatValue } from "./primitives/FloatType.js";
+import { formatIntegerValue } from "./primitives/IntegerType.js";
+import { formatStringValue } from "./primitives/StringType.js";
+import { formatChildEntitiesValue } from "./references/ChildEntitiesType.js";
+import { formatIncludeIdentifierValue } from "./references/IncludeIdentifierType.js";
+import { formatNestedEntityMapValue } from "./references/NestedEntityMapType.js";
+import { formatReferenceIdentifierValue } from "./references/ReferenceIdentifierType.js";
+import { formatTypeArgumentValue } from "./references/TypeArgumentType.js";
+export function walkTypeNodeTree(callbackFn, type, parentTypes, parentDecl) {
     switch (type.kind) {
         case NodeKind.ArrayType: {
-            callbackFn(type);
-            walkTypeNodeTree(callbackFn, type.items);
+            callbackFn(type, parentTypes, parentDecl);
+            walkTypeNodeTree(callbackFn, type.items, [...parentTypes, type], parentDecl);
             return;
         }
         case NodeKind.ObjectType: {
-            callbackFn(type);
+            callbackFn(type, parentTypes, parentDecl);
             Object.values(type.properties).forEach(prop => {
-                walkTypeNodeTree(callbackFn, prop.type);
+                walkTypeNodeTree(callbackFn, prop.type, [...parentTypes, type], parentDecl);
             });
             return;
         }
         case NodeKind.NestedEntityMapType: {
-            callbackFn(type);
-            walkTypeNodeTree(callbackFn, type.type.value);
+            callbackFn(type, parentTypes, parentDecl);
+            walkTypeNodeTree(callbackFn, type.type.value, [...parentTypes, type], parentDecl);
             return;
         }
         case NodeKind.BooleanType:
@@ -94,22 +38,23 @@ export function walkTypeNodeTree(callbackFn, type) {
         case NodeKind.IntegerType:
         case NodeKind.StringType:
         case NodeKind.TypeArgumentType:
-        case NodeKind.ReferenceIdentifierType: {
-            callbackFn(type);
+        case NodeKind.ReferenceIdentifierType:
+        case NodeKind.ChildEntitiesType: {
+            callbackFn(type, parentTypes, parentDecl);
             return;
         }
         case NodeKind.IncludeIdentifierType: {
-            callbackFn(type);
+            callbackFn(type, parentTypes, parentDecl);
             type.args.forEach(arg => {
-                walkTypeNodeTree(callbackFn, arg);
+                walkTypeNodeTree(callbackFn, arg, [...parentTypes, type], parentDecl);
             });
             return;
         }
         case NodeKind.EnumType: {
-            callbackFn(type);
+            callbackFn(type, parentTypes, parentDecl);
             Object.values(type.values).forEach(value => {
                 if (value.type) {
-                    walkTypeNodeTree(callbackFn, value.type);
+                    walkTypeNodeTree(callbackFn, value.type, [...parentTypes, type], parentDecl);
                 }
             });
             return;
@@ -118,31 +63,6 @@ export function walkTypeNodeTree(callbackFn, type) {
             return assertExhaustive(type);
     }
 }
-export const getParentDecl = (type) => {
-    if (type.parent === undefined) {
-        return undefined;
-    }
-    else if (isDecl(type.parent)) {
-        return type.parent;
-    }
-    else {
-        return getParentDecl(type.parent);
-    }
-};
-/**
- * Sets the `parent` property of the passed `type` to the passed `parentNode`.
- *
- * The property is set on the instance. It does not create a new instance.
- */
-export const setParent = (type, parentNode) => {
-    ;
-    type.parent = parentNode;
-    return type;
-};
-export const removeParentKey = (type) => {
-    const { parent: _parent, ...rest } = type;
-    return rest;
-};
 export const findTypeAtPath = (type, path) => {
     const [head, ...tail] = path;
     if (head === undefined) {
@@ -159,66 +79,6 @@ export const findTypeAtPath = (type, path) => {
     }
     return undefined;
 };
-export const serializeType = type => {
-    switch (type.kind) {
-        case NodeKind.ArrayType:
-            return serializeArrayType(type);
-        case NodeKind.ObjectType:
-            return serializeObjectType(type);
-        case NodeKind.BooleanType:
-            return serializeBooleanType(type);
-        case NodeKind.DateType:
-            return serializeDateType(type);
-        case NodeKind.FloatType:
-            return serializeFloatType(type);
-        case NodeKind.IntegerType:
-            return serializeIntegerType(type);
-        case NodeKind.StringType:
-            return serializeStringType(type);
-        case NodeKind.TypeArgumentType:
-            return serializeTypeArgumentType(type);
-        case NodeKind.ReferenceIdentifierType:
-            return serializeReferenceIdentifierType(type);
-        case NodeKind.IncludeIdentifierType:
-            return serializeIncludeIdentifierType(type);
-        case NodeKind.NestedEntityMapType:
-            return serializeNestedEntityMapType(type);
-        case NodeKind.EnumType:
-            return serializeEnumType(type);
-        default:
-            return assertExhaustive(type);
-    }
-};
-export const getReferencesForType = (type, value) => {
-    switch (type.kind) {
-        case NodeKind.ArrayType:
-            return getReferencesForArrayType(type, value);
-        case NodeKind.ObjectType:
-            return getReferencesForObjectType(type, value);
-        case NodeKind.BooleanType:
-            return getReferencesForBooleanType(type, value);
-        case NodeKind.DateType:
-            return getReferencesForDateType(type, value);
-        case NodeKind.FloatType:
-            return getReferencesForFloatType(type, value);
-        case NodeKind.IntegerType:
-            return getReferencesForIntegerType(type, value);
-        case NodeKind.StringType:
-            return getReferencesForStringType(type, value);
-        case NodeKind.TypeArgumentType:
-            return getReferencesForTypeArgumentType(type, value);
-        case NodeKind.ReferenceIdentifierType:
-            return getReferencesForReferenceIdentifierType(type, value);
-        case NodeKind.IncludeIdentifierType:
-            return getReferencesForIncludeIdentifierType(type, value);
-        case NodeKind.NestedEntityMapType:
-            return getReferencesForNestedEntityMapType(type, value);
-        case NodeKind.EnumType:
-            return getReferencesForEnumType(type, value);
-        default:
-            return assertExhaustive(type);
-    }
-};
 export const formatValue = (type, value) => {
     switch (type.kind) {
         case NodeKind.ArrayType:
@@ -245,6 +105,8 @@ export const formatValue = (type, value) => {
             return formatReferenceIdentifierValue(type, value);
         case NodeKind.EnumType:
             return formatEnumType(type, value);
+        case NodeKind.ChildEntitiesType:
+            return formatChildEntitiesValue(type, value);
         default:
             return assertExhaustive(type);
     }

package/dist/src/node/schema/types/generic/ArrayType.d.ts

@@ -1,8 +1,6 @@
-import type { GetNestedDeclarations } from "../../declarations/Declaration.ts";
-import type { GetReferences, Node, Serializer } from "../../Node.ts";
+import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, Validator } from "../../Node.ts";
 import { NodeKind } from "../../Node.ts";
-import type { Validator } from "../../validation/type.ts";
-import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.ts";
+import type { BaseType, StructureFormatter, Type } from "../Type.ts";
 export interface ArrayType<T extends Type = Type> extends BaseType {
     kind: NodeKind["ArrayType"];
     minItems?: number;
@@ -10,23 +8,16 @@ export interface ArrayType<T extends Type = Type> extends BaseType {
     uniqueItems?: boolean;
     items: T;
 }
-export interface SerializedArrayType<T extends SerializedType = SerializedType> extends SerializedBaseType {
-    kind: NodeKind["ArrayType"];
-    minItems?: number;
-    maxItems?: number;
-    uniqueItems?: boolean;
-    items: T;
-}
 export declare const ArrayType: <T extends Type>(items: T, options?: {
     minItems?: number;
     maxItems?: number;
     uniqueItems?: boolean;
 }) => ArrayType<T>;
 export { ArrayType as Array };
-export declare const isArrayType: (node: Node) => node is ArrayType;
+export declare const isArrayType: Predicate<ArrayType>;
 export declare const getNestedDeclarationsInArrayType: GetNestedDeclarations<ArrayType>;
 export declare const validateArrayType: Validator<ArrayType>;
-export declare const resolveTypeArgumentsInArrayType: (args: Record<string, Type>, type: ArrayType) => ArrayType;
-export declare const serializeArrayType: Serializer<ArrayType, SerializedArrayType>;
+export declare const resolveTypeArgumentsInArrayType: TypeArgumentsResolver<ArrayType>;
+export declare const serializeArrayType: Serializer<ArrayType>;
 export declare const getReferencesForArrayType: GetReferences<ArrayType>;
 export declare const formatArrayValue: StructureFormatter<ArrayType>;

package/dist/src/node/schema/types/generic/ArrayType.js

@@ -2,23 +2,18 @@ import { parallelizeErrors } from "../../../../shared/utils/validation.js";
 import { validateArrayConstraints } from "../../../../shared/validation/array.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
 import { json, key } from "../../../utils/errorFormatting.js";
-import { getNestedDeclarations } from "../../declarations/Declaration.js";
-import { NodeKind } from "../../Node.js";
+import { getNestedDeclarations, getReferences, NodeKind, resolveTypeArguments, serializeNode, validateType, } from "../../Node.js";
 import { validateOption } from "../../validation/options.js";
-import { formatValue, getReferencesForType, removeParentKey, resolveTypeArgumentsInType, serializeType, setParent, validate, } from "../Type.js";
-export const ArrayType = (items, options = {}) => {
-    const type = {
-        ...options,
-        kind: NodeKind.ArrayType,
-        minItems: validateOption(options.minItems, "minItems", option => Number.isInteger(option) && option >= 0),
-        maxItems: validateOption(options.maxItems, "maxItems", option => Number.isInteger(option) && option >= 0),
-        items,
-    };
-    setParent(type.items, type);
-    return type;
-};
+import { formatValue } from "../Type.js";
+export const ArrayType = (items, options = {}) => ({
+    ...options,
+    kind: NodeKind.ArrayType,
+    minItems: validateOption(options.minItems, "minItems", option => Number.isInteger(option) && option >= 0),
+    maxItems: validateOption(options.maxItems, "maxItems", option => Number.isInteger(option) && option >= 0),
+    items,
+});
 export { ArrayType as Array };
-export const isArrayType = (node) => node.kind === NodeKind.ArrayType;
+export const isArrayType = node => node.kind === NodeKind.ArrayType;
 export const getNestedDeclarationsInArrayType = (addedDecls, type) => getNestedDeclarations(addedDecls, type.items);
 export const validateArrayType = (helpers, type, value) => {
     if (!Array.isArray(value)) {
@@ -26,15 +21,15 @@ export const validateArrayType = (helpers, type, value) => {
     }
     return parallelizeErrors([
         ...validateArrayConstraints(type, value),
-        ...value.map((item, index) => wrapErrorsIfAny(`at index ${key(index.toString(), helpers.useStyling)}`, validate(helpers, type.items, item))),
+        ...value.map((item, index) => wrapErrorsIfAny(`at index ${key(index.toString(), helpers.useStyling)}`, validateType(helpers, type.items, item))),
     ]);
 };
-export const resolveTypeArgumentsInArrayType = (args, type) => ArrayType(resolveTypeArgumentsInType(args, type.items), {
+export const resolveTypeArgumentsInArrayType = (args, type) => ArrayType(resolveTypeArguments(args, type.items), {
     ...type,
 });
 export const serializeArrayType = type => ({
-    ...removeParentKey(type),
-    items: serializeType(type.items),
+    ...type,
+    items: serializeNode(type.items),
 });
-export const getReferencesForArrayType = (type, value) => Array.isArray(value) ? value.flatMap(item => getReferencesForType(type.items, item)) : [];
+export const getReferencesForArrayType = (type, value) => Array.isArray(value) ? value.flatMap(item => getReferences(type.items, item)) : [];
 export const formatArrayValue = (type, value) => Array.isArray(value) ? value.map(item => formatValue(type.items, item)) : value;

package/dist/src/node/schema/types/generic/EnumType.d.ts

@@ -1,39 +1,27 @@
-import type { GetNestedDeclarations } from "../../declarations/Declaration.ts";
-import type { GetReferences, Node, Serializer } from "../../Node.ts";
+import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, Validator } from "../../Node.ts";
 import { NodeKind } from "../../Node.ts";
-import type { Validator } from "../../validation/type.ts";
-import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.ts";
+import type { BaseType, StructureFormatter, Type } from "../Type.ts";
 export interface EnumType<T extends Record<string, EnumCaseDecl> = Record<string, EnumCaseDecl>> extends BaseType {
     kind: NodeKind["EnumType"];
     values: T;
 }
-export interface SerializedEnumType<T extends Record<string, SerializedEnumCaseDecl> = Record<string, SerializedEnumCaseDecl>> extends SerializedBaseType {
-    kind: NodeKind["EnumType"];
-    values: T;
-}
 export declare const EnumType: <T extends Record<string, EnumCaseDecl> = Record<string, EnumCaseDecl>>(values: T) => EnumType<T>;
-export declare const isEnumType: (node: Node) => node is EnumType;
+export declare const isEnumType: Predicate<EnumType>;
 export declare const getNestedDeclarationsInEnumType: GetNestedDeclarations<EnumType>;
 export declare const validateEnumType: Validator<EnumType>;
-export declare const resolveTypeArgumentsInEnumType: (args: Record<string, Type>, type: EnumType) => EnumType;
+export declare const resolveTypeArgumentsInEnumType: TypeArgumentsResolver<EnumType>;
 export interface EnumCaseDecl<T extends Type | null = Type | null> {
     kind: NodeKind["EnumCaseDecl"];
     type: T;
     comment?: string;
     isDeprecated?: boolean;
 }
-export interface SerializedEnumCaseDecl<T extends SerializedType | null = SerializedType | null> {
-    kind: NodeKind["EnumCaseDecl"];
-    type: T;
-    comment?: string;
-    isDeprecated?: boolean;
-}
 export declare const EnumCaseDecl: <T extends Type | null>(options: {
     type: T;
     comment?: string;
     isDeprecated?: boolean;
 }) => EnumCaseDecl<T>;
 export { EnumCaseDecl as EnumCase };
-export declare const serializeEnumType: Serializer<EnumType, SerializedEnumType>;
+export declare const serializeEnumType: Serializer<EnumType>;
 export declare const getReferencesForEnumType: GetReferences<EnumType>;
 export declare const formatEnumType: StructureFormatter<EnumType>;

package/dist/src/node/schema/types/generic/EnumType.js

@@ -2,21 +2,13 @@ import { discriminatorKey } from "../../../../shared/enum.js";
 import { parallelizeErrors } from "../../../../shared/utils/validation.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
 import { json, key } from "../../../utils/errorFormatting.js";
-import { getNestedDeclarations } from "../../declarations/Declaration.js";
-import { NodeKind } from "../../Node.js";
-import { formatValue, getReferencesForType, removeParentKey, resolveTypeArgumentsInType, serializeType, validate, } from "../Type.js";
-export const EnumType = (values) => {
-    const type = {
-        kind: NodeKind.EnumType,
-        values,
-    };
-    type.values = Object.fromEntries(Object.entries(values).map(([caseName, caseDef]) => [
-        caseName,
-        { ...caseDef, type: caseDef.type === null ? null : { ...caseDef.type, parent: type } },
-    ]));
-    return type;
-};
-export const isEnumType = (node) => node.kind === NodeKind.EnumType;
+import { getNestedDeclarations, getReferences, NodeKind, resolveTypeArguments, serializeNode, validateType, } from "../../Node.js";
+import { formatValue } from "../Type.js";
+export const EnumType = (values) => ({
+    kind: NodeKind.EnumType,
+    values,
+});
+export const isEnumType = node => node.kind === NodeKind.EnumType;
 export const getNestedDeclarationsInEnumType = (addedDecls, type) => Object.values(type.values).reduce((acc, caseMember) => caseMember.type === null ? acc : getNestedDeclarations(acc, caseMember.type), addedDecls);
 export const validateEnumType = (helpers, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -50,7 +42,7 @@ export const validateEnumType = (helpers, type, value) => {
             ];
         }
         return parallelizeErrors([
-            wrapErrorsIfAny(`at enum case ${key(`"${caseName}"`, helpers.useStyling)}`, validate(helpers, associatedType, value[caseName])),
+            wrapErrorsIfAny(`at enum case ${key(`"${caseName}"`, helpers.useStyling)}`, validateType(helpers, associatedType, value[caseName])),
         ]);
     }
     return [];
@@ -59,7 +51,7 @@ export const resolveTypeArgumentsInEnumType = (args, type) => EnumType(Object.fr
     key,
     {
         ...caseMember,
-        type: type === null ? null : resolveTypeArgumentsInType(args, type),
+        type: type === null ? null : resolveTypeArguments(args, type),
     },
 ])));
 export const EnumCaseDecl = (options) => ({
@@ -68,12 +60,12 @@ export const EnumCaseDecl = (options) => ({
 });
 export { EnumCaseDecl as EnumCase };
 export const serializeEnumType = type => ({
-    ...removeParentKey(type),
+    ...type,
     values: Object.fromEntries(Object.entries(type.values).map(([key, caseMember]) => [
         key,
         {
             ...caseMember,
-            type: caseMember.type === null ? null : serializeType(caseMember.type),
+            type: caseMember.type === null ? null : serializeNode(caseMember.type),
         },
     ])),
 });
@@ -90,7 +82,7 @@ export const getReferencesForEnumType = (type, value) => {
         type.values[enumCase] !== undefined &&
         type.values[enumCase].type !== null &&
         enumCase in value
-        ? getReferencesForType(type.values[enumCase].type, value[enumCase])
+        ? getReferences(type.values[enumCase].type, value[enumCase])
         : [];
 };
 export const formatEnumType = (type, value) => {

package/dist/src/node/schema/types/generic/ObjectType.d.ts

@@ -1,29 +1,22 @@
 import type { ObjectConstraints } from "../../../../shared/validation/object.ts";
-import type { GetNestedDeclarations } from "../../declarations/Declaration.ts";
-import type { GetReferences, Node, Serializer } from "../../Node.ts";
+import type { GetNestedDeclarations, GetReferences, Predicate, Serialized, TypeArgumentsResolver, Validator } from "../../Node.ts";
 import { NodeKind } from "../../Node.ts";
-import type { Validator } from "../../validation/type.ts";
-import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.ts";
+import type { BaseType, StructureFormatter, Type } from "../Type.ts";
 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>;
-export interface SerializedObjectType<T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType, ObjectConstraints {
-    kind: NodeKind["ObjectType"];
-    properties: T;
-}
 export declare const ObjectType: <T extends TConstraint>(properties: T, options?: {
     additionalProperties?: boolean;
     minProperties?: number;
     maxProperties?: number;
 }) => ObjectType<T>;
 export { ObjectType as Object };
-export declare const isObjectType: (node: Node) => node is ObjectType;
+export declare const isObjectType: Predicate<ObjectType>;
 export declare const getNestedDeclarationsInObjectType: GetNestedDeclarations<ObjectType>;
 export declare const validateObjectType: Validator<ObjectType>;
-export declare const resolveTypeArgumentsInObjectType: (args: Record<string, Type>, type: ObjectType) => ObjectType;
+export declare const resolveTypeArgumentsInObjectType: TypeArgumentsResolver<ObjectType>;
 export interface MemberDecl<T extends Type = Type, R extends boolean = boolean> {
     kind: NodeKind["MemberDecl"];
     isRequired: R;
@@ -31,13 +24,6 @@ export interface MemberDecl<T extends Type = Type, R extends boolean = boolean>
     comment?: string;
     isDeprecated?: boolean;
 }
-export interface SerializedMemberDecl<T extends SerializedType = SerializedType, R extends boolean = boolean> {
-    kind: NodeKind["MemberDecl"];
-    isRequired: R;
-    type: T;
-    comment?: string;
-    isDeprecated?: boolean;
-}
 export declare const Required: <T extends Type>(options: {
     comment?: string;
     isDeprecated?: boolean;
@@ -48,6 +34,6 @@ export declare const Optional: <T extends Type>(options: {
     isDeprecated?: boolean;
     type: T;
 }) => MemberDecl<T, false>;
-export declare const serializeObjectType: Serializer<ObjectType, SerializedObjectType>;
+export declare const serializeObjectType: <P extends TConstraint>(type: ObjectType<P>) => Serialized<ObjectType<P>>;
 export declare const getReferencesForObjectType: GetReferences<ObjectType>;
 export declare const formatObjectValue: StructureFormatter<ObjectType>;

package/dist/src/node/schema/types/generic/ObjectType.js

@@ -3,10 +3,10 @@ import { parallelizeErrors } from "../../../../shared/utils/validation.js";
 import { validateObjectConstraints } from "../../../../shared/validation/object.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
 import { json, key as keyColor } from "../../../utils/errorFormatting.js";
-import { getNestedDeclarations } from "../../declarations/Declaration.js";
-import { NodeKind } from "../../Node.js";
+import { getNestedDeclarations, getReferences, NodeKind, resolveTypeArguments, serializeNode, validateType, } from "../../Node.js";
 import { validateOption } from "../../validation/options.js";
-import { formatValue, getReferencesForType, removeParentKey, resolveTypeArgumentsInType, serializeType, setParent, validate, } from "../Type.js";
+import { isChildEntitiesType } from "../references/ChildEntitiesType.js";
+import { formatValue } from "../Type.js";
 const keyPattern = /^[a-zA-Z0-9][a-zA-Z0-9_]*$/;
 export const ObjectType = (properties, options = {}) => {
     const type = {
@@ -20,19 +20,17 @@ 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
-        setParent(properties[key].type, type);
     });
     return type;
 };
 export { ObjectType as Object };
-export const isObjectType = (node) => node.kind === NodeKind.ObjectType;
+export const isObjectType = node => node.kind === NodeKind.ObjectType;
 export const getNestedDeclarationsInObjectType = (addedDecls, type) => Object.values(type.properties).reduce((acc, prop) => getNestedDeclarations(acc, prop.type), addedDecls);
 export const validateObjectType = (helpers, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return [TypeError(`expected an object, but got ${json(value, helpers.useStyling)}`)];
     }
-    const expectedKeys = Object.keys(type.properties);
+    const expectedKeys = Object.keys(type.properties).filter(key => type.properties[key] !== undefined && !isChildEntitiesType(type.properties[key].type));
     return parallelizeErrors([
         ...validateObjectConstraints(type, expectedKeys, value),
         ...expectedKeys.map(key => {
@@ -42,13 +40,13 @@ export const validateObjectType = (helpers, type, value) => {
                 return TypeError(`missing required property ${keyColor(`"${key}"`, helpers.useStyling)}`);
             }
             else if (prop.isRequired || value[key] !== undefined) {
-                return wrapErrorsIfAny(`at object key ${keyColor(`"${key}"`, helpers.useStyling)}`, validate(helpers, prop.type, value[key]));
+                return wrapErrorsIfAny(`at object key ${keyColor(`"${key}"`, helpers.useStyling)}`, validateType(helpers, prop.type, value[key]));
             }
             return undefined;
         }),
     ]);
 };
-export const resolveTypeArgumentsInObjectType = (args, type) => ObjectType(Object.fromEntries(Object.entries(type.properties).map(([key, config]) => [key, { ...config, type: resolveTypeArgumentsInType(args, config.type) }])), {
+export const resolveTypeArgumentsInObjectType = (args, type) => ObjectType(Object.fromEntries(Object.entries(type.properties).map(([key, config]) => [key, { ...config, type: resolveTypeArguments(args, config.type) }])), {
     ...type,
 });
 const MemberDecl = (isRequired, type, comment, isDeprecated) => ({
@@ -60,20 +58,18 @@ const MemberDecl = (isRequired, type, comment, isDeprecated) => ({
 });
 export const Required = (options) => MemberDecl(true, options.type, options.comment, options.isDeprecated);
 export const Optional = (options) => MemberDecl(false, options.type, options.comment, options.isDeprecated);
-export const serializeObjectType = type => ({
-    ...removeParentKey(type),
+export const serializeObjectType = (type) => ({
+    ...type,
     properties: Object.fromEntries(Object.entries(type.properties).map(([key, prop]) => [
         key,
         {
             ...prop,
-            type: serializeType(prop.type),
+            type: serializeNode(prop.type),
         },
     ])),
 });
 export const getReferencesForObjectType = (type, value) => typeof value === "object" && value !== null
-    ? 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) : [])
+    ? Object.entries(value).flatMap(([key, propValue]) => type.properties[key] ? getReferences(type.properties[key].type, propValue) : [])
     : [];
 export const formatObjectValue = (type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
     ? sortObjectKeys(Object.fromEntries(Object.entries(value).map(([key, item]) => [

package/dist/src/node/schema/types/primitives/BooleanType.d.ts

@@ -1,17 +1,16 @@
-import type { GetReferences, Node, Serializer } from "../../Node.ts";
+import type { GetNestedDeclarations, TypeArgumentsResolver } from "../../index.ts";
+import type { GetReferences, Predicate, Serializer, Validator } from "../../Node.ts";
 import { NodeKind } from "../../Node.ts";
-import type { Validator } from "../../validation/type.ts";
-import type { BaseType, SerializedBaseType, StructureFormatter } from "../Type.ts";
+import type { BaseType, StructureFormatter } from "../Type.ts";
 export interface BooleanType extends BaseType {
     kind: NodeKind["BooleanType"];
 }
-export interface SerializedBooleanType extends SerializedBaseType {
-    kind: NodeKind["BooleanType"];
-}
 export declare const BooleanType: () => BooleanType;
 export { BooleanType as Boolean };
-export declare const isBooleanType: (node: Node) => node is BooleanType;
+export declare const isBooleanType: Predicate<BooleanType>;
+export declare const getNestedDeclarationsInBooleanType: GetNestedDeclarations<BooleanType>;
 export declare const validateBooleanType: Validator<BooleanType>;
-export declare const serializeBooleanType: Serializer<BooleanType, SerializedBooleanType>;
+export declare const resolveTypeArgumentsInBooleanType: TypeArgumentsResolver<BooleanType>;
+export declare const serializeBooleanType: Serializer<BooleanType>;
 export declare const getReferencesForBooleanType: GetReferences<BooleanType>;
 export declare const formatBooleanValue: StructureFormatter<BooleanType>;

package/dist/src/node/schema/types/primitives/BooleanType.js

@@ -1,17 +1,18 @@
 import { json } from "../../../utils/errorFormatting.js";
 import { NodeKind } from "../../Node.js";
-import { removeParentKey } from "../Type.js";
 export const BooleanType = () => ({
     kind: NodeKind.BooleanType,
 });
 export { BooleanType as Boolean };
-export const isBooleanType = (node) => node.kind === NodeKind.BooleanType;
+export const isBooleanType = node => node.kind === NodeKind.BooleanType;
+export const getNestedDeclarationsInBooleanType = addedDecls => addedDecls;
 export const validateBooleanType = (helpers, _type, value) => {
     if (typeof value !== "boolean") {
         return [TypeError(`expected a boolean value, but got ${json(value, helpers.useStyling)}`)];
     }
     return [];
 };
-export const serializeBooleanType = type => removeParentKey(type);
-export const getReferencesForBooleanType = (_type, _value) => [];
+export const resolveTypeArgumentsInBooleanType = (_args, type) => type;
+export const serializeBooleanType = type => type;
+export const getReferencesForBooleanType = () => [];
 export const formatBooleanValue = (_type, value) => value;