tsondb 0.5.18 → 0.6.0

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

@@ -1,18 +1,16 @@
 import type { DateConstraints } from "../../../../shared/validation/date.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, StructureFormatter } from "../Type.ts";
+import type { BaseType, StructureFormatter } from "../Type.ts";
 export interface DateType extends BaseType, DateConstraints {
     kind: NodeKind["DateType"];
 }
-export interface SerializedDateType extends SerializedBaseType, DateConstraints {
-    kind: NodeKind["DateType"];
-}
 export declare const DateType: (options?: DateConstraints) => DateType;
 export { DateType as Date };
-export declare const isDateType: (node: Node) => node is DateType;
+export declare const isDateType: Predicate<DateType>;
+export declare const getNestedDeclarationsInDateType: GetNestedDeclarations<DateType>;
 export declare const validateDateType: Validator<DateType>;
-export declare const serializeDateType: Serializer<DateType, SerializedDateType>;
+export declare const resolveTypeArgumentsInDateType: TypeArgumentsResolver<DateType>;
+export declare const serializeDateType: Serializer<DateType>;
 export declare const getReferencesForDateType: GetReferences<DateType>;
 export declare const formatDateValue: StructureFormatter<DateType>;

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

@@ -1,19 +1,20 @@
 import { validateDateConstraints } from "../../../../shared/validation/date.js";
 import { json } from "../../../utils/errorFormatting.js";
 import { NodeKind } from "../../Node.js";
-import { removeParentKey } from "../Type.js";
 export const DateType = (options) => ({
     ...options,
     kind: NodeKind.DateType,
 });
 export { DateType as Date };
-export const isDateType = (node) => node.kind === NodeKind.DateType;
+export const isDateType = node => node.kind === NodeKind.DateType;
+export const getNestedDeclarationsInDateType = addedDecls => addedDecls;
 export const validateDateType = (helpers, type, value) => {
     if (typeof value !== "string") {
         return [TypeError(`expected a string, but got ${json(value, helpers.useStyling)}`)];
     }
     return validateDateConstraints(type, value);
 };
-export const serializeDateType = type => removeParentKey(type);
-export const getReferencesForDateType = (_type, _value) => [];
+export const resolveTypeArgumentsInDateType = (_args, type) => type;
+export const serializeDateType = type => type;
+export const getReferencesForDateType = () => [];
 export const formatDateValue = (_type, value) => value;

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

@@ -1,28 +1,16 @@
-import type { RangeBound } from "../../../../shared/validation/number.ts";
-import type { GetReferences, Node, Serializer } from "../../Node.ts";
+import type { NumberConstraints } from "../../../../shared/validation/number.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, StructureFormatter } from "../Type.ts";
-export interface FloatType extends BaseType {
+import type { BaseType, StructureFormatter } from "../Type.ts";
+export interface FloatType extends BaseType, NumberConstraints {
     kind: NodeKind["FloatType"];
-    minimum?: RangeBound;
-    maximum?: RangeBound;
-    multipleOf?: number;
 }
-export interface SerializedFloatType extends SerializedBaseType {
-    kind: NodeKind["FloatType"];
-    minimum?: RangeBound;
-    maximum?: RangeBound;
-    multipleOf?: number;
-}
-export declare const FloatType: (options?: {
-    minimum?: RangeBound;
-    maximum?: RangeBound;
-    multipleOf?: number;
-}) => FloatType;
+export declare const FloatType: (options?: NumberConstraints) => FloatType;
 export { FloatType as Float };
-export declare const isFloatType: (node: Node) => node is FloatType;
+export declare const isFloatType: Predicate<FloatType>;
+export declare const getNestedDeclarationsInFloatType: GetNestedDeclarations<FloatType>;
 export declare const validateFloatType: Validator<FloatType>;
-export declare const serializeFloatType: Serializer<FloatType, SerializedFloatType>;
+export declare const resolveTypeArgumentsInFloatType: TypeArgumentsResolver<FloatType>;
+export declare const serializeFloatType: Serializer<FloatType>;
 export declare const getReferencesForFloatType: GetReferences<FloatType>;
 export declare const formatFloatValue: StructureFormatter<FloatType>;

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

@@ -1,13 +1,13 @@
 import { validateNumberConstraints } from "../../../../shared/validation/number.js";
 import { json } from "../../../utils/errorFormatting.js";
 import { NodeKind } from "../../Node.js";
-import { removeParentKey } from "../Type.js";
 export const FloatType = (options = {}) => ({
     ...options,
     kind: NodeKind.FloatType,
 });
 export { FloatType as Float };
-export const isFloatType = (node) => node.kind === NodeKind.FloatType;
+export const isFloatType = node => node.kind === NodeKind.FloatType;
+export const getNestedDeclarationsInFloatType = addedDecls => addedDecls;
 export const validateFloatType = (helpers, type, value) => {
     if (typeof value !== "number") {
         return [
@@ -16,6 +16,7 @@ export const validateFloatType = (helpers, type, value) => {
     }
     return validateNumberConstraints(type, value);
 };
-export const serializeFloatType = type => removeParentKey(type);
-export const getReferencesForFloatType = (_type, _value) => [];
+export const resolveTypeArgumentsInFloatType = (_args, type) => type;
+export const serializeFloatType = type => type;
+export const getReferencesForFloatType = () => [];
 export const formatFloatValue = (_type, value) => value;

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

@@ -1,28 +1,16 @@
-import type { RangeBound } from "../../../../shared/validation/number.ts";
-import type { GetReferences, Node, Serializer } from "../../Node.ts";
+import type { NumberConstraints } from "../../../../shared/validation/number.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, StructureFormatter } from "../Type.ts";
-export interface IntegerType extends BaseType {
+import type { BaseType, StructureFormatter } from "../Type.ts";
+export interface IntegerType extends BaseType, NumberConstraints {
     kind: NodeKind["IntegerType"];
-    minimum?: RangeBound;
-    maximum?: RangeBound;
-    multipleOf?: number;
 }
-export interface SerializedIntegerType extends SerializedBaseType {
-    kind: NodeKind["IntegerType"];
-    minimum?: RangeBound;
-    maximum?: RangeBound;
-    multipleOf?: number;
-}
-export declare const IntegerType: (options?: {
-    minimum?: RangeBound;
-    maximum?: RangeBound;
-    multipleOf?: number;
-}) => IntegerType;
+export declare const IntegerType: (options?: NumberConstraints) => IntegerType;
 export { IntegerType as Integer };
-export declare const isIntegerType: (node: Node) => node is IntegerType;
+export declare const isIntegerType: Predicate<IntegerType>;
+export declare const getNestedDeclarationsInIntegerType: GetNestedDeclarations<IntegerType>;
 export declare const validateIntegerType: Validator<IntegerType>;
-export declare const serializeIntegerType: Serializer<IntegerType, SerializedIntegerType>;
+export declare const resolveTypeArgumentsInIntegerType: TypeArgumentsResolver<IntegerType>;
+export declare const serializeIntegerType: Serializer<IntegerType>;
 export declare const getReferencesForIntegerType: GetReferences<IntegerType>;
 export declare const formatIntegerValue: StructureFormatter<IntegerType>;

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

@@ -2,7 +2,6 @@ import { validateNumberConstraints } from "../../../../shared/validation/number.
 import { json } from "../../../utils/errorFormatting.js";
 import { NodeKind } from "../../Node.js";
 import { validateOption } from "../../validation/options.js";
-import { removeParentKey } from "../Type.js";
 const isIntegerRangeBoundOption = (option) => Number.isInteger(typeof option === "number" ? option : option.value);
 export const IntegerType = (options = {}) => ({
     kind: NodeKind.IntegerType,
@@ -11,13 +10,15 @@ export const IntegerType = (options = {}) => ({
     multipleOf: options.multipleOf,
 });
 export { IntegerType as Integer };
-export const isIntegerType = (node) => node.kind === NodeKind.IntegerType;
+export const isIntegerType = node => node.kind === NodeKind.IntegerType;
+export const getNestedDeclarationsInIntegerType = addedDecls => addedDecls;
 export const validateIntegerType = (helpers, type, value) => {
     if (typeof value !== "number" || !Number.isInteger(value)) {
         return [TypeError(`expected an integer, but got ${json(value, helpers.useStyling)}`)];
     }
     return validateNumberConstraints(type, value);
 };
-export const serializeIntegerType = type => removeParentKey(type);
-export const getReferencesForIntegerType = (_type, _value) => [];
+export const resolveTypeArgumentsInIntegerType = (_args, type) => type;
+export const serializeIntegerType = type => type;
+export const getReferencesForIntegerType = () => [];
 export const formatIntegerValue = (_type, value) => value;

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

@@ -1,18 +1,12 @@
 import type { StringConstraints } from "../../../../shared/validation/string.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, StructureFormatter } from "../Type.ts";
+import type { BaseType, StructureFormatter } from "../Type.ts";
 export interface StringType extends BaseType, StringConstraints {
     kind: NodeKind["StringType"];
     pattern?: RegExp;
     isMarkdown?: boolean;
 }
-export interface SerializedStringType extends SerializedBaseType, StringConstraints {
-    kind: NodeKind["StringType"];
-    pattern?: string;
-    isMarkdown?: boolean;
-}
 export declare const StringType: (options?: {
     minLength?: number;
     maxLength?: number;
@@ -20,8 +14,10 @@ export declare const StringType: (options?: {
     isMarkdown?: boolean;
 }) => StringType;
 export { StringType as String };
-export declare const isStringType: (node: Node) => node is StringType;
+export declare const isStringType: Predicate<StringType>;
+export declare const getNestedDeclarationsInStringType: GetNestedDeclarations<StringType>;
 export declare const validateStringType: Validator<StringType>;
-export declare const serializeStringType: Serializer<StringType, SerializedStringType>;
+export declare const resolveTypeArgumentsInStringType: TypeArgumentsResolver<StringType>;
+export declare const serializeStringType: Serializer<StringType>;
 export declare const getReferencesForStringType: GetReferences<StringType>;
 export declare const formatStringValue: StructureFormatter<StringType>;

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

@@ -1,22 +1,23 @@
 import { validateStringConstraints } from "../../../../shared/validation/string.js";
 import { json } from "../../../utils/errorFormatting.js";
 import { NodeKind } from "../../Node.js";
-import { removeParentKey } from "../Type.js";
 export const StringType = (options = {}) => ({
     ...options,
     kind: NodeKind.StringType,
 });
 export { StringType as String };
-export const isStringType = (node) => node.kind === NodeKind.StringType;
+export const isStringType = node => node.kind === NodeKind.StringType;
+export const getNestedDeclarationsInStringType = addedDecls => addedDecls;
 export const validateStringType = (helpers, type, value) => {
     if (typeof value !== "string") {
         return [TypeError(`expected a string, but got ${json(value, helpers.useStyling)}`)];
     }
     return validateStringConstraints(type, value);
 };
-export const serializeStringType = type => removeParentKey({
+export const resolveTypeArgumentsInStringType = (_args, type) => type;
+export const serializeStringType = type => ({
     ...type,
     pattern: type.pattern?.source,
 });
-export const getReferencesForStringType = (_type, _value) => [];
+export const getReferencesForStringType = () => [];
 export const formatStringValue = (_type, value) => value;

package/dist/src/node/schema/types/references/ChildEntitiesType.d.ts

@@ -0,0 +1,18 @@
+import { type EntityDecl } from "../../declarations/EntityDecl.ts";
+import { type GetNestedDeclarations, type GetReferences, type Predicate, type Serializer, type TypeArgumentsResolver, type Validator } from "../../Node.js";
+import { NodeKind } from "../../Node.ts";
+import type { MemberDecl } from "../generic/ObjectType.ts";
+import type { BaseType, StructureFormatter } from "../Type.ts";
+export interface ChildEntitiesType<T extends EntityDecl<string, Record<string, MemberDecl>, string> = EntityDecl<string, Record<string, MemberDecl>, string>> extends BaseType {
+    kind: NodeKind["ChildEntitiesType"];
+    entity: T;
+}
+export declare const ChildEntitiesType: <T extends EntityDecl<string, Record<string, MemberDecl>, string>>(entity: T) => ChildEntitiesType<T>;
+export { ChildEntitiesType as ChildEntities };
+export declare const isChildEntitiesType: Predicate<ChildEntitiesType>;
+export declare const getNestedDeclarationsInChildEntitiesType: GetNestedDeclarations<ChildEntitiesType>;
+export declare const validateChildEntitiesType: Validator<ChildEntitiesType>;
+export declare const resolveTypeArgumentsInChildEntitiesType: TypeArgumentsResolver<ChildEntitiesType>;
+export declare const serializeChildEntitiesType: Serializer<ChildEntitiesType>;
+export declare const getReferencesForChildEntitiesType: GetReferences<ChildEntitiesType>;
+export declare const formatChildEntitiesValue: StructureFormatter<ChildEntitiesType>;

package/dist/src/node/schema/types/references/ChildEntitiesType.js

@@ -0,0 +1,18 @@
+import {} from "../../declarations/EntityDecl.js";
+import {} from "../../Node.js";
+import { getNestedDeclarations, NodeKind } from "../../Node.js";
+export const ChildEntitiesType = (entity) => ({
+    kind: NodeKind.ChildEntitiesType,
+    entity,
+});
+export { ChildEntitiesType as ChildEntities };
+export const isChildEntitiesType = node => node.kind === NodeKind.ChildEntitiesType;
+export const getNestedDeclarationsInChildEntitiesType = (addedDecls, type) => getNestedDeclarations([type.entity, ...addedDecls], type.entity);
+export const validateChildEntitiesType = () => [];
+export const resolveTypeArgumentsInChildEntitiesType = (_args, type) => type;
+export const serializeChildEntitiesType = type => ({
+    ...type,
+    entity: type.entity.name,
+});
+export const getReferencesForChildEntitiesType = (_type, value) => (Array.isArray(value) && value.every(id => typeof id === "string") ? value : []);
+export const formatChildEntitiesValue = (_type, value) => Array.isArray(value) ? value.toSorted() : value;

package/dist/src/node/schema/types/references/IncludeIdentifierType.d.ts

@@ -1,32 +1,26 @@
-import type { GetNestedDeclarations, IncludableDeclP, SerializedTypeArguments, TypeArguments } from "../../declarations/Declaration.ts";
+import type { SerializedIncludeIdentifierType } from "../../../../shared/schema/types/IncludeIdentifierType.ts";
+import type { IncludableDeclP, TypeArguments } from "../../declarations/Declaration.ts";
 import type { EnumDecl } from "../../declarations/EnumDecl.ts";
 import type { TypeAliasDecl } from "../../declarations/TypeAliasDecl.ts";
-import type { GetReferences, Node, Serializer } from "../../Node.ts";
+import type { GetNestedDeclarations, GetReferences, Predicate, SerializedTypeParameters, Validator } from "../../Node.ts";
 import { NodeKind } from "../../Node.ts";
-import type { SerializedTypeParameter, TypeParameter } from "../../TypeParameter.ts";
-import type { Validator } from "../../validation/type.ts";
+import type { TypeParameter } from "../../TypeParameter.ts";
 import type { EnumCaseDecl } from "../generic/EnumType.ts";
-import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.ts";
+import type { BaseType, StructureFormatter, Type } from "../Type.ts";
 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"];
     reference: T;
     args: TypeArguments<Params>;
 }
-export interface SerializedIncludeIdentifierType<Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> extends SerializedBaseType {
-    kind: NodeKind["IncludeIdentifierType"];
-    reference: string;
-    args: SerializedTypeArguments<Params>;
-}
 export declare const GenIncludeIdentifierType: <T extends TConstraint<Params>, Params extends TypeParameter[] = []>(reference: T, args: TypeArguments<Params>) => IncludeIdentifierType<Params, T>;
 export { GenIncludeIdentifierType as GenIncludeIdentifier };
 export declare const IncludeIdentifierType: <T extends TConstraint<[]>>(reference: T) => IncludeIdentifierType<[], T>;
 export { IncludeIdentifierType as IncludeIdentifier };
-export declare const isIncludeIdentifierType: (node: Node) => node is IncludeIdentifierType;
-export declare const isNoGenericIncludeIdentifierType: (node: IncludeIdentifierType) => node is IncludeIdentifierType<[], IncludableDeclP<[]>>;
+export declare const isIncludeIdentifierType: Predicate<IncludeIdentifierType>;
 export declare const getNestedDeclarationsInIncludeIdentifierType: GetNestedDeclarations<IncludeIdentifierType>;
 export declare const validateIncludeIdentifierType: Validator<IncludeIdentifierType>;
 export declare const resolveTypeArgumentsInIncludeIdentifierType: <T extends IncludeIdentifierType>(args: Record<string, Type>, type: T) => T extends IncludeIdentifierType<[], IncludableDeclP<[]>> ? T : Type;
-export declare const serializeIncludeIdentifierType: Serializer<IncludeIdentifierType, SerializedIncludeIdentifierType>;
+export declare const serializeIncludeIdentifierType: <Params extends TypeParameter[] = TypeParameter<string, Type>[], T extends TConstraint<Params> = TConstraint<Params>>(type: IncludeIdentifierType<Params, T>) => SerializedIncludeIdentifierType<SerializedTypeParameters<Params>>;
 export declare const getReferencesForIncludeIdentifierType: GetReferences<IncludeIdentifierType>;
 export declare const formatIncludeIdentifierValue: StructureFormatter<IncludeIdentifierType>;

package/dist/src/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 { getTypeArgumentsRecord } from "../../declarations/Declaration.js";
+import { getNestedDeclarations, getReferences, NodeKind, resolveTypeArguments, serializeNode, validateDecl, } from "../../Node.js";
 import { formatEnumType } from "../generic/EnumType.js";
-import { formatValue, removeParentKey, resolveTypeArgumentsInType, serializeType } from "../Type.js";
+import { formatValue } from "../Type.js";
 export const GenIncludeIdentifierType = (reference, args) => ({
     kind: NodeKind.IncludeIdentifierType,
     reference,
@@ -14,21 +14,21 @@ export const IncludeIdentifierType = (reference) => ({
     args: [],
 });
 export { IncludeIdentifierType as IncludeIdentifier };
-export const isIncludeIdentifierType = (node) => node.kind === NodeKind.IncludeIdentifierType;
-export const isNoGenericIncludeIdentifierType = (node) => node.args.length === 0 && node.reference.parameters.length === 0;
+export const isIncludeIdentifierType = node => node.kind === NodeKind.IncludeIdentifierType;
+const isNoGenericIncludeIdentifierType = (node) => node.args.length === 0 && node.reference.parameters.length === 0;
 export const getNestedDeclarationsInIncludeIdentifierType = (addedDecls, type) => type.args.reduce((accAddedDecls, arg) => getNestedDeclarations(accAddedDecls, arg), addedDecls.includes(type.reference)
     ? addedDecls
     : getNestedDeclarations([type.reference, ...addedDecls], type.reference));
 export const validateIncludeIdentifierType = (helpers, type, value) => validateDecl(helpers, type.reference, type.args, value);
-export const resolveTypeArgumentsInIncludeIdentifierType = (args, type) => (isNoGenericIncludeIdentifierType(type)
+export const resolveTypeArgumentsInIncludeIdentifierType = ((args, type) => (isNoGenericIncludeIdentifierType(type)
     ? type
-    : resolveTypeArgumentsInDecl(type.reference, type.args.map(arg => resolveTypeArgumentsInType(args, arg))).type.value);
-export const serializeIncludeIdentifierType = type => ({
-    ...removeParentKey(type),
+    : resolveTypeArguments(getTypeArgumentsRecord(type.reference, type.args.map(arg => resolveTypeArguments(args, arg))), type.reference).type.value));
+export const serializeIncludeIdentifierType = ((type) => ({
+    ...type,
     reference: type.reference.name,
-    args: type.args.map(arg => serializeType(arg)),
-});
-export const getReferencesForIncludeIdentifierType = (type, value) => getReferencesForDecl(resolveTypeArgumentsInDecl(type.reference, type.args), value);
+    args: type.args.map(arg => serializeNode(arg)),
+}));
+export const getReferencesForIncludeIdentifierType = (type, value) => getReferences(resolveTypeArguments(getTypeArgumentsRecord(type.reference, type.args), type.reference), value);
 export const formatIncludeIdentifierValue = (type, value) => {
     switch (type.reference.kind) {
         case NodeKind.TypeAliasDecl:

package/dist/src/node/schema/types/references/NestedEntityMapType.d.ts

@@ -1,13 +1,11 @@
 import { Lazy } from "../../../../shared/utils/lazy.ts";
-import { type GetNestedDeclarations } from "../../declarations/Declaration.ts";
 import type { EntityDecl } from "../../declarations/EntityDecl.ts";
 import type { TypeAliasDecl } from "../../declarations/TypeAliasDecl.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 { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "../generic/ObjectType.ts";
-import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.ts";
-import { type IncludeIdentifier, type SerializedIncludeIdentifierType } from "./IncludeIdentifierType.ts";
+import type { MemberDecl, ObjectType } from "../generic/ObjectType.ts";
+import type { BaseType, StructureFormatter } from "../Type.ts";
+import { type IncludeIdentifier } from "./IncludeIdentifierType.ts";
 type TConstraint = Record<string, MemberDecl>;
 type PossibleType<T extends TConstraint> = ObjectType<T> | IncludeIdentifier<[], TypeAliasDecl<string, ObjectType<T>, []>>;
 export interface NestedEntityMapType<Name extends string = string, T extends TConstraint = TConstraint> extends BaseType {
@@ -17,14 +15,6 @@ export interface NestedEntityMapType<Name extends string = string, T extends TCo
     secondaryEntity: EntityDecl;
     type: Lazy<PossibleType<T>>;
 }
-type TSerializedConstraint = Record<string, SerializedMemberDecl>;
-export interface SerializedNestedEntityMapType<Name extends string = string, T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
-    kind: NodeKind["NestedEntityMapType"];
-    name: Name;
-    comment?: string;
-    secondaryEntity: string;
-    type: SerializedObjectType<T> | SerializedIncludeIdentifierType;
-}
 export declare const NestedEntityMapType: <Name extends string, T extends TConstraint>(options: {
     name: Name;
     comment?: string;
@@ -32,10 +22,10 @@ export declare const NestedEntityMapType: <Name extends string, T extends TConst
     type: PossibleType<T>;
 }) => NestedEntityMapType<Name, T>;
 export { NestedEntityMapType as NestedEntityMap };
-export declare const isNestedEntityMapType: (node: Node) => node is NestedEntityMapType;
+export declare const isNestedEntityMapType: Predicate<NestedEntityMapType>;
 export declare const getNestedDeclarationsInNestedEntityMapType: GetNestedDeclarations<NestedEntityMapType>;
 export declare const validateNestedEntityMapType: Validator<NestedEntityMapType>;
-export declare const resolveTypeArgumentsInNestedEntityMapType: (args: Record<string, Type>, type: NestedEntityMapType) => NestedEntityMapType;
-export declare const serializeNestedEntityMapType: Serializer<NestedEntityMapType, SerializedNestedEntityMapType>;
+export declare const resolveTypeArgumentsInNestedEntityMapType: TypeArgumentsResolver<NestedEntityMapType>;
+export declare const serializeNestedEntityMapType: Serializer<NestedEntityMapType>;
 export declare const getReferencesForNestedEntityMapType: GetReferences<NestedEntityMapType>;
 export declare const formatNestedEntityMapValue: StructureFormatter<NestedEntityMapType>;

package/dist/src/node/schema/types/references/NestedEntityMapType.js

@@ -3,16 +3,16 @@ import { sortObjectKeysAlphabetically } from "../../../../shared/utils/object.js
 import { parallelizeErrors } from "../../../../shared/utils/validation.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
 import { entity, json, key as keyColor } from "../../../utils/errorFormatting.js";
-import { getNestedDeclarations, } from "../../declarations/Declaration.js";
-import { NodeKind } from "../../Node.js";
-import { getReferencesForObjectType, isObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, } from "../generic/ObjectType.js";
-import { formatValue, removeParentKey, setParent, validate } from "../Type.js";
-import { formatIncludeIdentifierValue, getReferencesForIncludeIdentifierType, resolveTypeArgumentsInIncludeIdentifierType, serializeIncludeIdentifierType, } from "./IncludeIdentifierType.js";
+import {} from "../../declarations/Declaration.js";
+import { getNestedDeclarations, NodeKind, resolveTypeArguments, validateType } from "../../Node.js";
+import { getReferencesForObjectType, isObjectType, serializeObjectType, } from "../generic/ObjectType.js";
+import { formatValue } from "../Type.js";
+import { formatIncludeIdentifierValue, getReferencesForIncludeIdentifierType, serializeIncludeIdentifierType, } from "./IncludeIdentifierType.js";
 export const NestedEntityMapType = (options) => {
     const nestedEntityMapType = {
         ...options,
         kind: NodeKind.NestedEntityMapType,
-        type: Lazy.of(() => setParent(options.type, nestedEntityMapType)),
+        type: Lazy.of(() => options.type),
     };
     return nestedEntityMapType;
 };
@@ -21,29 +21,27 @@ const _NestedEntityMapType = (options) => {
     const nestedEntityMapType = {
         ...options,
         kind: NodeKind.NestedEntityMapType,
-        type: Lazy.of(() => setParent(options.type(), nestedEntityMapType)),
+        type: Lazy.of(() => options.type()),
     };
     return nestedEntityMapType;
 };
-export const isNestedEntityMapType = (node) => node.kind === NodeKind.NestedEntityMapType;
+export const isNestedEntityMapType = node => node.kind === NodeKind.NestedEntityMapType;
 export const getNestedDeclarationsInNestedEntityMapType = (addedDecls, type) => getNestedDeclarations(addedDecls.includes(type.secondaryEntity) ? addedDecls : [type.secondaryEntity, ...addedDecls], type.type.value);
 export const validateNestedEntityMapType = (helpers, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return [TypeError(`expected an object, but got ${json(value, helpers.useStyling)}`)];
     }
-    return parallelizeErrors(Object.keys(value).map(key => wrapErrorsIfAny(`at nested entity map ${entity(`"${type.name}"`, helpers.useStyling)} at key ${keyColor(`"${key}"`, helpers.useStyling)}`, validate(helpers, type.type.value, value[key]).concat(helpers.checkReferentialIntegrity({
+    return parallelizeErrors(Object.keys(value).map(key => wrapErrorsIfAny(`at nested entity map ${entity(`"${type.name}"`, helpers.useStyling)} at key ${keyColor(`"${key}"`, helpers.useStyling)}`, validateType(helpers, type.type.value, value[key]).concat(helpers.checkReferentialIntegrity({
         name: type.secondaryEntity.name,
         value: key,
     })))));
 };
 export const resolveTypeArgumentsInNestedEntityMapType = (args, type) => _NestedEntityMapType({
     ...type,
-    type: () => isObjectType(type.type.value)
-        ? resolveTypeArgumentsInObjectType(args, type.type.value)
-        : resolveTypeArgumentsInIncludeIdentifierType(args, type.type.value),
+    type: () => resolveTypeArguments(args, type.type.value),
 });
 export const serializeNestedEntityMapType = type => ({
-    ...removeParentKey(type),
+    ...type,
     secondaryEntity: type.secondaryEntity.name,
     type: isObjectType(type.type.value)
         ? serializeObjectType(type.type.value)

package/dist/src/node/schema/types/references/ReferenceIdentifierType.d.ts

@@ -1,23 +1,17 @@
-import type { GetNestedDeclarations } from "../../declarations/Declaration.ts";
 import type { EntityDecl } from "../../declarations/EntityDecl.ts";
-import type { GetReferences, Node, Serializer } from "../../Node.ts";
+import type { GetNestedDeclarations, GetReferences, Node, Serializer, TypeArgumentsResolver, Validator } from "../../Node.ts";
 import { NodeKind } from "../../Node.ts";
-import type { Validator } from "../../validation/type.ts";
-import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.ts";
+import type { BaseType, StructureFormatter } from "../Type.ts";
 export interface ReferenceIdentifierType extends BaseType {
     kind: NodeKind["ReferenceIdentifierType"];
     entity: EntityDecl;
 }
-export interface SerializedReferenceIdentifierType extends SerializedBaseType {
-    kind: NodeKind["ReferenceIdentifierType"];
-    entity: string;
-}
 export declare const ReferenceIdentifierType: (entity: EntityDecl) => ReferenceIdentifierType;
 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: Record<string, Type>, type: ReferenceIdentifierType) => ReferenceIdentifierType;
-export declare const serializeReferenceIdentifierType: Serializer<ReferenceIdentifierType, SerializedReferenceIdentifierType>;
+export declare const resolveTypeArgumentsInReferenceIdentifierType: TypeArgumentsResolver<ReferenceIdentifierType>;
+export declare const serializeReferenceIdentifierType: Serializer<ReferenceIdentifierType>;
 export declare const getReferencesForReferenceIdentifierType: GetReferences<ReferenceIdentifierType>;
 export declare const formatReferenceIdentifierValue: StructureFormatter<ReferenceIdentifierType>;

package/dist/src/node/schema/types/references/ReferenceIdentifierType.js

@@ -1,7 +1,5 @@
-import { getNestedDeclarations } from "../../declarations/Declaration.js";
 import { createEntityIdentifierType } from "../../declarations/EntityDecl.js";
-import { NodeKind } from "../../Node.js";
-import { removeParentKey, validate } from "../Type.js";
+import { getNestedDeclarations, NodeKind, validateType } from "../../Node.js";
 export const ReferenceIdentifierType = (entity) => ({
     kind: NodeKind.ReferenceIdentifierType,
     entity,
@@ -11,13 +9,13 @@ export const isReferenceIdentifierType = (node) => node.kind === NodeKind.Refere
 export const getNestedDeclarationsInReferenceIdentifierType = (addedDecls, type) => addedDecls.includes(type.entity)
     ? addedDecls
     : getNestedDeclarations([...addedDecls, type.entity], type.entity);
-export const validateReferenceIdentifierType = (helpers, type, value) => validate(helpers, createEntityIdentifierType(), value).concat(helpers.checkReferentialIntegrity({
+export const validateReferenceIdentifierType = (helpers, type, value) => validateType(helpers, createEntityIdentifierType(), value).concat(helpers.checkReferentialIntegrity({
     name: type.entity.name,
     value: value,
 }));
 export const resolveTypeArgumentsInReferenceIdentifierType = (_args, type) => type;
 export const serializeReferenceIdentifierType = type => ({
-    ...removeParentKey(type),
+    ...type,
     entity: type.entity.name,
 });
 export const getReferencesForReferenceIdentifierType = (_type, value) => (typeof value === "string" ? [value] : []);

package/dist/src/node/schema/types/references/TypeArgumentType.d.ts

@@ -1,23 +1,18 @@
-import type { GetReferences, Node, Serializer } from "../../Node.ts";
+import type { GetNestedDeclarations, GetReferences, Node, Serializer, Validator } from "../../Node.ts";
 import { NodeKind } from "../../Node.ts";
-import type { SerializedTypeParameter, TypeParameter } from "../../TypeParameter.ts";
-import type { Validator } from "../../validation/type.ts";
-import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.ts";
+import type { TypeParameter } from "../../TypeParameter.ts";
+import type { BaseType, StructureFormatter, Type } from "../Type.ts";
 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 getNestedDeclarationsInTypeArgumentType: GetNestedDeclarations<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 serializeTypeArgumentType: Serializer<TypeArgumentType>;
 export declare const getReferencesForTypeArgumentType: GetReferences<TypeArgumentType>;
 export declare const formatTypeArgumentValue: StructureFormatter<TypeArgumentType>;

package/dist/src/node/schema/types/references/TypeArgumentType.js

@@ -1,19 +1,24 @@
 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) => {
+export const getNestedDeclarationsInTypeArgumentType = addedDecls => addedDecls;
+export const validateTypeArgumentType = (_helpers, type) => {
     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 resolveTypeArgumentsInTypeArgumentType = ((args, type) => {
+    if (!(type.argument.name in args)) {
+        throw new TypeError(`no generic argument provided for "${type.argument.name}"`);
+    }
+    return args[type.argument.name];
+});
 export const serializeTypeArgumentType = type => ({
-    ...removeParentKey(type),
+    ...type,
     argument: serializeTypeParameter(type.argument),
 });
-export const getReferencesForTypeArgumentType = (_type, _value) => [];
+export const getReferencesForTypeArgumentType = () => [];
 export const formatTypeArgumentValue = (_type, value) => value;