tsondb 0.5.19 → 0.6.1

package/dist/src/node/schema/declarations/Declaration.js

@@ -1,126 +1,24 @@
-import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
-import { NodeKind } from "../Node.js";
-import { getNestedDeclarationsInArrayType } from "../types/generic/ArrayType.js";
-import { getNestedDeclarationsInEnumType } from "../types/generic/EnumType.js";
-import { getNestedDeclarationsInObjectType } from "../types/generic/ObjectType.js";
-import { getNestedDeclarationsInIncludeIdentifierType } from "../types/references/IncludeIdentifierType.js";
-import { getNestedDeclarationsInNestedEntityMapType } from "../types/references/NestedEntityMapType.js";
-import { getNestedDeclarationsInReferenceIdentifierType } from "../types/references/ReferenceIdentifierType.js";
+import { resolveTypeArguments } from "../Node.js";
 import { walkTypeNodeTree } from "../types/Type.js";
-import { getNestedDeclarationsInEntityDecl, getReferencesForEntityDecl, isEntityDecl, resolveTypeArgumentsInEntityDecl, serializeEntityDecl, validateEntityDecl, } from "./EntityDecl.js";
-import { getNestedDeclarationsInEnumDecl, getReferencesForEnumDecl, isEnumDecl, resolveTypeArgumentsInEnumDecl, serializeEnumDecl, validateEnumDecl, } from "./EnumDecl.js";
-import { getNestedDeclarationsInTypeAliasDecl, getReferencesForTypeAliasDecl, isTypeAliasDecl, resolveTypeArgumentsInTypeAliasDecl, serializeTypeAliasDecl, validateTypeAliasDecl, } from "./TypeAliasDecl.js";
+import { isEntityDecl } from "./EntityDecl.js";
+import { isEnumDecl } from "./EnumDecl.js";
+import { isTypeAliasDecl } from "./TypeAliasDecl.js";
 export const getParameterNames = (decl) => decl.parameters.map(param => param.name);
 export const getTypeArgumentsRecord = (decl, args) => Object.fromEntries(
 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 args.slice(0, decl.parameters.length).map((arg, i) => [decl.parameters[i].name, arg]));
-export const getNestedDeclarations = (addedDecls, node) => {
-    switch (node.kind) {
-        case NodeKind.EntityDecl:
-            return getNestedDeclarationsInEntityDecl(addedDecls, node);
-        case NodeKind.EnumDecl:
-            return getNestedDeclarationsInEnumDecl(addedDecls, node);
-        case NodeKind.TypeAliasDecl:
-            return getNestedDeclarationsInTypeAliasDecl(addedDecls, node);
-        case NodeKind.ArrayType:
-            return getNestedDeclarationsInArrayType(addedDecls, node);
-        case NodeKind.ObjectType:
-            return getNestedDeclarationsInObjectType(addedDecls, node);
-        case NodeKind.BooleanType:
-        case NodeKind.DateType:
-        case NodeKind.FloatType:
-        case NodeKind.IntegerType:
-        case NodeKind.StringType:
-        case NodeKind.TypeArgumentType:
-            return addedDecls;
-        case NodeKind.ReferenceIdentifierType:
-            return getNestedDeclarationsInReferenceIdentifierType(addedDecls, node);
-        case NodeKind.IncludeIdentifierType:
-            return getNestedDeclarationsInIncludeIdentifierType(addedDecls, node);
-        case NodeKind.NestedEntityMapType:
-            return getNestedDeclarationsInNestedEntityMapType(addedDecls, node);
-        case NodeKind.EnumType:
-            return getNestedDeclarationsInEnumType(addedDecls, node);
-        default:
-            return assertExhaustive(node);
-    }
-};
 export const isDecl = (node) => isEntityDecl(node) || isEnumDecl(node) || isTypeAliasDecl(node);
-export const validateDecl = (helpers, decl, args, value) => {
-    switch (decl.kind) {
-        case NodeKind.EntityDecl:
-            return validateEntityDecl(helpers, decl, value);
-        case NodeKind.EnumDecl:
-            return validateEnumDecl(helpers, decl, args, value);
-        case NodeKind.TypeAliasDecl:
-            return validateTypeAliasDecl(helpers, decl, args, value);
-        default:
-            return assertExhaustive(decl);
-    }
-};
+export const asDecl = (node) => node && isDecl(node) ? node : undefined;
 const declNamePattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 export const validateDeclName = (name) => {
     if (!declNamePattern.test(name)) {
         throw new Error(`Invalid declaration name "${name}". Declaration names must match the pattern ${declNamePattern.toString()}.`);
     }
 };
-export const resolveTypeArgumentsInDecl = (decl, args) => {
-    switch (decl.kind) {
-        case NodeKind.EntityDecl:
-            return resolveTypeArgumentsInEntityDecl(decl);
-        case NodeKind.EnumDecl:
-            return resolveTypeArgumentsInEnumDecl(decl, args);
-        case NodeKind.TypeAliasDecl:
-            return resolveTypeArgumentsInTypeAliasDecl(decl, args);
-        default:
-            return assertExhaustive(decl);
-    }
-};
 export const isDeclWithoutTypeParameters = (decl) => decl.parameters.length === 0;
-export const resolveTypeArgumentsInDecls = (decls) => decls.filter(isDeclWithoutTypeParameters).map(decl => resolveTypeArgumentsInDecl(decl, []));
+export const resolveTypeArgumentsInDecls = (decls) => decls.filter(isDeclWithoutTypeParameters).map(decl => resolveTypeArguments({}, decl));
 export function walkNodeTree(callbackFn, decl) {
-    switch (decl.kind) {
-        case NodeKind.EntityDecl: {
-            callbackFn(decl);
-            walkTypeNodeTree(callbackFn, decl.type.value);
-            return;
-        }
-        case NodeKind.EnumDecl: {
-            callbackFn(decl);
-            walkTypeNodeTree(callbackFn, decl.type.value);
-            return;
-        }
-        case NodeKind.TypeAliasDecl: {
-            callbackFn(decl);
-            walkTypeNodeTree(callbackFn, decl.type.value);
-            return;
-        }
-        default:
-            return assertExhaustive(decl);
-    }
+    callbackFn(decl, [], decl);
+    walkTypeNodeTree(callbackFn, decl.type.value, [], decl);
 }
-export const serializeDecl = decl => {
-    switch (decl.kind) {
-        case NodeKind.EntityDecl:
-            return serializeEntityDecl(decl);
-        case NodeKind.EnumDecl:
-            return serializeEnumDecl(decl);
-        case NodeKind.TypeAliasDecl:
-            return serializeTypeAliasDecl(decl);
-        default:
-            return assertExhaustive(decl);
-    }
-};
-export const getReferencesForDecl = (decl, value) => {
-    switch (decl.kind) {
-        case NodeKind.EntityDecl:
-            return getReferencesForEntityDecl(decl, value);
-        case NodeKind.EnumDecl:
-            return getReferencesForEnumDecl(decl, value);
-        case NodeKind.TypeAliasDecl:
-            return getReferencesForTypeAliasDecl(decl, value);
-        default:
-            return assertExhaustive(decl);
-    }
-};
 export const groupDeclarationsBySourceUrl = (decls) => Object.groupBy(decls, decl => decl.sourceUrl);

package/dist/src/node/schema/declarations/EntityDecl.d.ts

@@ -1,81 +1,81 @@
+import type { DisplayNameResult } from "../../../shared/utils/displayName.ts";
 import { Lazy } from "../../../shared/utils/lazy.ts";
 import type { Leaves } from "../../../shared/utils/object.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 { MemberDecl, ObjectType, SerializedObjectType } from "../types/generic/ObjectType.ts";
+import type { MemberDecl, ObjectType } from "../types/generic/ObjectType.ts";
 import { StringType } from "../types/primitives/StringType.ts";
-import type { AsType, SerializedAsType } from "../types/Type.ts";
-import type { ValidatorHelpers } from "../validation/type.ts";
-import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl } from "./Declaration.ts";
+import type { AsType } from "../types/Type.ts";
+import type { BaseDecl } from "./Declaration.ts";
 import { TypeAliasDecl } from "./TypeAliasDecl.ts";
-export type GenericDisplayNameFn = (instance: unknown, instanceDisplayName: string, getInstanceById: (id: string) => unknown, getDisplayNameForInstanceId: (id: string) => string | undefined, locales: string[] | undefined) => string;
+export type GenericDisplayNameFn = (instance: unknown, instanceDisplayName: string, getInstanceById: (id: string) => unknown, getDisplayNameForInstanceId: (id: string) => string | undefined, locales: string[]) => string;
 export type GenericEntityDisplayName = string | {
     pathToLocaleMap?: string;
     pathInLocaleMap?: string;
 } | null;
-export type DisplayNameFn<T extends ObjectType = ObjectType> = (instance: AsType<T>, instanceDisplayName: string, getInstanceById: (id: string) => unknown, getDisplayNameForInstanceId: (id: string) => string | undefined, locales: string[] | undefined) => string;
-export type EntityDisplayName<T extends ObjectType> = Leaves<AsType<T>> | {
+export type DisplayNameFn<T extends ObjectType = ObjectType> = (instance: AsType<T>, instanceDisplayName: string, instanceDisplayNameLocaleId: string | undefined, getInstanceById: (id: string) => unknown, getDisplayNameForInstanceId: (id: string) => string | undefined, locales: string[]) => DisplayNameResult;
+export type EntityDisplayName<T extends TConstraint> = Leaves<AsType<ObjectType<T>>> | {
     /**
      * @default "translations"
      */
-    pathToLocaleMap?: Leaves<AsType<T>>;
+    pathToLocaleMap?: Leaves<AsType<ObjectType<T>>>;
     /**
      * @default "name"
      */
     pathInLocaleMap?: string;
 } | null;
-export type SerializedEntityDisplayName<T extends SerializedObjectType> = Leaves<SerializedAsType<T>> | {
-    /**
-     * @default "translations"
-     */
-    pathToLocaleMap?: Leaves<SerializedAsType<T>>;
-    /**
-     * @default "name"
-     */
-    pathInLocaleMap?: string;
-} | null;
-export interface EntityDecl<Name extends string = string, T extends ObjectType = ObjectType> extends BaseDecl<Name, []> {
+type TConstraint = Record<string, MemberDecl>;
+export interface EntityDecl<Name extends string = string, T extends TConstraint = TConstraint, FK extends (keyof T & string) | undefined = (keyof T & string) | undefined> extends BaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
     namePlural: string;
-    type: Lazy<T>;
+    type: Lazy<ObjectType<T>>;
+    parentReferenceKey: FK;
     /**
      * @default "name"
      */
     displayName?: EntityDisplayName<T>;
-    displayNameCustomizer?: DisplayNameFn<T>;
+    displayNameCustomizer?: DisplayNameFn<ObjectType<T>>;
     isDeprecated?: boolean;
 }
-export interface SerializedEntityDecl<Name extends string = string, T extends SerializedObjectType = SerializedObjectType> extends SerializedBaseDecl<Name, []> {
-    kind: NodeKind["EntityDecl"];
-    namePlural: string;
-    type: T;
-    /**
-     * @default "name"
-     */
-    displayName?: SerializedEntityDisplayName<T>;
-    isDeprecated?: boolean;
+export interface EntityDeclWithParentReference<Name extends string = string, T extends TConstraint = TConstraint, FK extends keyof T & string = keyof T & string> extends EntityDecl<Name, T, FK> {
 }
-export declare const EntityDecl: <Name extends string, T extends ObjectType>(sourceUrl: string, options: {
-    name: Name;
-    namePlural: string;
-    comment?: string;
-    type: () => T;
-    /**
-     * @default "name"
-     */
-    displayName?: EntityDisplayName<T>;
-    displayNameCustomizer?: DisplayNameFn<T>;
-    isDeprecated?: boolean;
-}) => EntityDecl<Name, T>;
+export declare const EntityDecl: {
+    <Name extends string, T extends TConstraint>(sourceUrl: string, options: {
+        name: Name;
+        namePlural: string;
+        comment?: string;
+        type: () => ObjectType<T>;
+        /**
+         * @default "name"
+         */
+        displayName?: EntityDisplayName<T>;
+        displayNameCustomizer?: DisplayNameFn<ObjectType<T>>;
+        isDeprecated?: boolean;
+    }): EntityDecl<Name, T, undefined>;
+    <Name extends string, T extends TConstraint, FK extends keyof T & string>(sourceUrl: string, options: {
+        name: Name;
+        namePlural: string;
+        comment?: string;
+        type: () => ObjectType<T>;
+        parentReferenceKey: FK;
+        /**
+         * @default "name"
+         */
+        displayName?: EntityDisplayName<T>;
+        displayNameCustomizer?: DisplayNameFn<ObjectType<T>>;
+        isDeprecated?: boolean;
+    }): EntityDecl<Name, T, FK>;
+};
 export { EntityDecl as Entity };
-export declare const isEntityDecl: (node: Node) => node is EntityDecl;
+export declare const isEntityDecl: Predicate<EntityDecl>;
+export declare const isEntityDeclWithParentReference: <Name extends string, T extends TConstraint, FK extends (keyof T & string) | undefined>(decl: EntityDecl<Name, T, FK>) => decl is EntityDecl<Name, T, NonNullable<FK>>;
 export declare const getNestedDeclarationsInEntityDecl: GetNestedDeclarations<EntityDecl>;
-export declare const validateEntityDecl: (helpers: ValidatorHelpers, decl: EntityDecl, value: unknown) => Error[];
-export declare const resolveTypeArgumentsInEntityDecl: (decl: EntityDecl) => EntityDecl;
-export declare const addEphemeralUUIDToType: <T extends Record<string, MemberDecl>>(decl: EntityDecl<string, ObjectType<T>>) => ObjectType<Omit<T, "id"> & {
+export declare const validateEntityDecl: Validator<EntityDecl>;
+export declare const resolveTypeArgumentsInEntityDecl: TypeArgumentsResolver<EntityDecl>;
+export declare const addEphemeralUUIDToType: <T extends TConstraint>(decl: EntityDecl<string, T>) => ObjectType<Omit<T, "id"> & {
     id: MemberDecl<StringType, true>;
 }>;
 export declare const createEntityIdentifierType: () => StringType;
 export declare const createEntityIdentifierTypeAsDecl: <Name extends string>(decl: EntityDecl<Name>) => TypeAliasDecl<`${Name}_ID`, StringType, []>;
-export declare const serializeEntityDecl: Serializer<EntityDecl, SerializedEntityDecl>;
+export declare const serializeEntityDecl: Serializer<EntityDecl>;
 export declare const getReferencesForEntityDecl: GetReferences<EntityDecl>;

package/dist/src/node/schema/declarations/EntityDecl.js

@@ -1,13 +1,12 @@
 import { Lazy } from "../../../shared/utils/lazy.js";
-import { NodeKind } from "../Node.js";
-import { getNestedDeclarationsInObjectType, getReferencesForObjectType, Required, resolveTypeArgumentsInObjectType, serializeObjectType, } from "../types/generic/ObjectType.js";
+import { NodeKind, resolveTypeArguments, validateType } from "../Node.js";
+import { getNestedDeclarationsInObjectType, getReferencesForObjectType, Required, serializeObjectType, } from "../types/generic/ObjectType.js";
 import { StringType } from "../types/primitives/StringType.js";
-import { setParent, validate } from "../types/Type.js";
 import { validateDeclName } from "./Declaration.js";
 import { TypeAliasDecl } from "./TypeAliasDecl.js";
 export const EntityDecl = (sourceUrl, options) => {
     validateDeclName(options.name);
-    const decl = {
+    return {
         ...options,
         kind: NodeKind.EntityDecl,
         sourceUrl,
@@ -19,18 +18,19 @@ export const EntityDecl = (sourceUrl, options) => {
                     throw new TypeError(`Invalid object key "${key}" for entity "${options.name}". The key "id" is reserved for the entity identifier.`);
                 }
             });
-            return setParent(type, decl);
+            return type;
         }),
+        parentReferenceKey: options.parentReferenceKey,
     };
-    return decl;
 };
 export { EntityDecl as Entity };
-export const isEntityDecl = (node) => node.kind === NodeKind.EntityDecl;
+export const isEntityDecl = node => node.kind === NodeKind.EntityDecl;
+export const isEntityDeclWithParentReference = (decl) => decl.parentReferenceKey !== undefined;
 export const getNestedDeclarationsInEntityDecl = (isDeclAdded, decl) => getNestedDeclarationsInObjectType(isDeclAdded, decl.type.value);
-export const validateEntityDecl = (helpers, decl, value) => validate(helpers, decl.type.value, value);
-export const resolveTypeArgumentsInEntityDecl = (decl) => EntityDecl(decl.sourceUrl, {
+export const validateEntityDecl = (helpers, decl, value) => validateType(helpers, decl.type.value, value);
+export const resolveTypeArgumentsInEntityDecl = (_args, decl) => EntityDecl(decl.sourceUrl, {
     ...decl,
-    type: () => resolveTypeArgumentsInObjectType({}, decl.type.value),
+    type: () => resolveTypeArguments({}, decl.type.value),
 });
 const createEntityIdentifierComment = () => "The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.";
 export const addEphemeralUUIDToType = (decl) => ({
@@ -49,9 +49,12 @@ export const createEntityIdentifierTypeAsDecl = (decl) => TypeAliasDecl(decl.sou
     name: (decl.name + "_ID"),
     type: createEntityIdentifierType,
 });
-export const serializeEntityDecl = type => ({
+export const serializeEntityDecl = (type) => ({
     ...type,
     type: serializeObjectType(type.type.value),
-    displayName: typeof type.displayName === "function" ? null : type.displayName,
+    displayName: typeof type.displayName === "function"
+        ? null
+        : type.displayName,
+    displayNameCustomizer: type.displayNameCustomizer !== undefined,
 });
 export const getReferencesForEntityDecl = (decl, value) => getReferencesForObjectType(decl.type.value, value);

package/dist/src/node/schema/declarations/EnumDecl.d.ts

@@ -1,38 +1,35 @@
 import { Lazy } from "../../../shared/utils/lazy.ts";
-import type { GetReferences, Node, Serializer } from "../Node.ts";
+import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, ValidatorOfParamDecl } from "../Node.ts";
 import { NodeKind } from "../Node.ts";
-import type { SerializedTypeParameter, TypeParameter } from "../TypeParameter.ts";
-import type { EnumCaseDecl, SerializedEnumCaseDecl, SerializedEnumType } from "../types/generic/EnumType.ts";
+import type { TypeParameter } from "../TypeParameter.ts";
+import type { EnumCaseDecl } from "../types/generic/EnumType.ts";
 import { EnumType } from "../types/generic/EnumType.ts";
-import { type Type } from "../types/Type.ts";
-import type { ValidatorHelpers } from "../validation/type.ts";
-import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.ts";
-export interface EnumDecl<Name extends string = string, T extends Record<string, EnumCaseDecl> = Record<string, EnumCaseDecl>, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
+import type { BaseDecl } from "./Declaration.ts";
+type TConstraint = Record<string, EnumCaseDecl>;
+export interface EnumDecl<Name extends string = string, T extends TConstraint = TConstraint, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
     kind: NodeKind["EnumDecl"];
     type: Lazy<EnumType<T>>;
     isDeprecated?: boolean;
 }
-export interface SerializedEnumDecl<Name extends string = string, T extends Record<string, SerializedEnumCaseDecl> = Record<string, SerializedEnumCaseDecl>, Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> extends SerializedBaseDecl<Name, Params> {
-    kind: NodeKind["EnumDecl"];
-    type: SerializedEnumType<T>;
-    isDeprecated?: boolean;
-}
-export declare const GenEnumDecl: <Name extends string, T extends Record<string, EnumCaseDecl>, Params extends TypeParameter[]>(sourceUrl: string, options: {
+export declare const GenEnumDecl: <Name extends string, T extends TConstraint, Params extends TypeParameter[]>(sourceUrl: string, options: {
     name: Name;
     comment?: string;
     parameters: Params;
+    isDeprecated?: boolean;
     values: (...args: Params) => T;
 }) => EnumDecl<Name, T, Params>;
 export { GenEnumDecl as GenEnum };
 export declare const EnumDecl: <Name extends string, T extends Record<string, EnumCaseDecl>>(sourceUrl: string, options: {
     name: Name;
     comment?: string;
+    isDeprecated?: boolean;
     values: () => T;
 }) => EnumDecl<Name, T, []>;
 export { EnumDecl as Enum };
-export declare const isEnumDecl: (node: Node) => node is EnumDecl;
+export declare const isEnumDecl: Predicate<EnumDecl>;
 export declare const getNestedDeclarationsInEnumDecl: GetNestedDeclarations<EnumDecl>;
-export declare const validateEnumDecl: (helpers: ValidatorHelpers, decl: EnumDecl, args: Type[], value: unknown) => Error[];
-export declare const resolveTypeArgumentsInEnumDecl: <Params extends TypeParameter[]>(decl: EnumDecl<string, Record<string, EnumCaseDecl>, Params>, args: TypeArguments<Params>) => EnumDecl<string, Record<string, EnumCaseDecl>, []>;
-export declare const serializeEnumDecl: Serializer<EnumDecl, SerializedEnumDecl>;
+export declare const validateEnumDecl: ValidatorOfParamDecl<EnumDecl>;
+export declare const resolveTypeArgumentsInEnumDecl: TypeArgumentsResolver<EnumDecl>;
+export declare const serializeEnumDecl: Serializer<EnumDecl>;
 export declare const getReferencesForEnumDecl: GetReferences<EnumDecl>;
+export declare const cases: <T extends TConstraint>(decl: EnumDecl<string, T>) => EnumCaseDecl<T[keyof T]["type"]>[];

package/dist/src/node/schema/declarations/EnumDecl.js

@@ -1,8 +1,8 @@
 import { Lazy } from "../../../shared/utils/lazy.js";
+import { onlyKeys } from "../../../shared/utils/object.js";
 import { NodeKind } from "../Node.js";
 import { serializeTypeParameter } from "../TypeParameter.js";
 import { EnumType, getNestedDeclarationsInEnumType, getReferencesForEnumType, resolveTypeArgumentsInEnumType, serializeEnumType, validateEnumType, } from "../types/generic/EnumType.js";
-import { setParent } from "../types/Type.js";
 import { getTypeArgumentsRecord, validateDeclName } from "./Declaration.js";
 export const GenEnumDecl = (sourceUrl, options) => {
     validateDeclName(options.name);
@@ -10,7 +10,7 @@ export const GenEnumDecl = (sourceUrl, options) => {
         ...options,
         kind: NodeKind.EnumDecl,
         sourceUrl,
-        type: Lazy.of(() => setParent(EnumType(options.values(...options.parameters)), decl)),
+        type: Lazy.of(() => EnumType(options.values(...options.parameters))),
     };
     return decl;
 };
@@ -18,28 +18,28 @@ export { GenEnumDecl as GenEnum };
 export const EnumDecl = (sourceUrl, options) => {
     validateDeclName(options.name);
     const decl = {
-        ...options,
+        ...onlyKeys(options, "name", "comment", "isDeprecated"),
         kind: NodeKind.EnumDecl,
         sourceUrl,
         parameters: [],
-        type: Lazy.of(() => setParent(EnumType(options.values()), decl)),
+        type: Lazy.of(() => EnumType(options.values())),
     };
     return decl;
 };
 export { EnumDecl as Enum };
-export const isEnumDecl = (node) => node.kind === NodeKind.EnumDecl;
+export const isEnumDecl = node => node.kind === NodeKind.EnumDecl;
 export const getNestedDeclarationsInEnumDecl = (addedDecls, decl) => getNestedDeclarationsInEnumType(addedDecls, decl.type.value);
 export const validateEnumDecl = (helpers, decl, args, value) => validateEnumType(helpers, resolveTypeArgumentsInEnumType(getTypeArgumentsRecord(decl, args), decl.type.value), value);
-export const resolveTypeArgumentsInEnumDecl = (decl, args) => {
-    const resolvedArgs = getTypeArgumentsRecord(decl, args);
-    return EnumDecl(decl.sourceUrl, {
-        ...decl,
-        values: () => resolveTypeArgumentsInEnumType(resolvedArgs, decl.type.value).values,
-    });
-};
+export const resolveTypeArgumentsInEnumDecl = (args, decl) => EnumDecl(decl.sourceUrl, {
+    name: decl.name,
+    comment: decl.comment,
+    isDeprecated: decl.isDeprecated,
+    values: () => resolveTypeArgumentsInEnumType(args, decl.type.value).values,
+});
 export const serializeEnumDecl = decl => ({
     ...decl,
     type: serializeEnumType(decl.type.value),
     parameters: decl.parameters.map(param => serializeTypeParameter(param)),
 });
 export const getReferencesForEnumDecl = (decl, value) => getReferencesForEnumType(decl.type.value, value);
+export const cases = (decl) => Object.values(decl.type.value.values);

package/dist/src/node/schema/declarations/TypeAliasDecl.d.ts

@@ -1,20 +1,14 @@
 import { Lazy } from "../../../shared/utils/lazy.ts";
-import type { GetReferences, Node, Serializer } from "../Node.ts";
+import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, Validators } from "../Node.ts";
 import { NodeKind } from "../Node.ts";
-import type { SerializedTypeParameter, TypeParameter } from "../TypeParameter.ts";
-import type { SerializedType, Type } from "../types/Type.ts";
-import type { ValidatorHelpers } from "../validation/type.ts";
-import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.ts";
+import type { TypeParameter } from "../TypeParameter.ts";
+import type { Type } from "../types/Type.ts";
+import type { BaseDecl, TypeArguments } from "./Declaration.ts";
 export interface TypeAliasDecl<Name extends string = string, T extends Type = Type, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
     kind: NodeKind["TypeAliasDecl"];
     type: Lazy<T>;
     isDeprecated?: boolean;
 }
-export interface SerializedTypeAliasDecl<Name extends string = string, T extends SerializedType = SerializedType, Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> extends SerializedBaseDecl<Name, Params> {
-    kind: NodeKind["TypeAliasDecl"];
-    type: T;
-    isDeprecated?: boolean;
-}
 export declare const GenTypeAliasDecl: <Name extends string, T extends Type, Params extends TypeParameter[]>(sourceUrl: string, options: {
     name: Name;
     comment?: string;
@@ -30,9 +24,9 @@ export declare const TypeAliasDecl: <Name extends string, T extends Type>(source
     type: () => T;
 }) => TypeAliasDecl<Name, T, []>;
 export { TypeAliasDecl as TypeAlias };
-export declare const isTypeAliasDecl: (node: Node) => node is TypeAliasDecl;
+export declare const isTypeAliasDecl: Predicate<TypeAliasDecl>;
 export declare const getNestedDeclarationsInTypeAliasDecl: GetNestedDeclarations<TypeAliasDecl>;
-export declare const validateTypeAliasDecl: <Params extends TypeParameter[]>(helpers: ValidatorHelpers, decl: TypeAliasDecl<string, Type, Params>, args: TypeArguments<Params>, value: unknown) => Error[];
-export declare const resolveTypeArgumentsInTypeAliasDecl: <Params extends TypeParameter[]>(decl: TypeAliasDecl<string, Type, Params>, args: TypeArguments<Params>) => TypeAliasDecl<string, Type, []>;
-export declare const serializeTypeAliasDecl: Serializer<TypeAliasDecl, SerializedTypeAliasDecl>;
+export declare const validateTypeAliasDecl: <Params extends TypeParameter[]>(helpers: Validators, decl: TypeAliasDecl<string, Type, Params>, args: TypeArguments<Params>, value: unknown) => Error[];
+export declare const resolveTypeArgumentsInTypeAliasDecl: TypeArgumentsResolver<TypeAliasDecl>;
+export declare const serializeTypeAliasDecl: Serializer<TypeAliasDecl>;
 export declare const getReferencesForTypeAliasDecl: GetReferences<TypeAliasDecl>;

package/dist/src/node/schema/declarations/TypeAliasDecl.js

@@ -1,15 +1,14 @@
 import { Lazy } from "../../../shared/utils/lazy.js";
-import { NodeKind } from "../Node.js";
+import { getNestedDeclarations, getReferences, NodeKind, resolveTypeArguments, serializeNode, validateType, } from "../Node.js";
 import { serializeTypeParameter } from "../TypeParameter.js";
-import { getReferencesForType, resolveTypeArgumentsInType, serializeType, setParent, validate, } from "../types/Type.js";
-import { getNestedDeclarations, getTypeArgumentsRecord, validateDeclName } from "./Declaration.js";
+import { getTypeArgumentsRecord, validateDeclName } from "./Declaration.js";
 export const GenTypeAliasDecl = (sourceUrl, options) => {
     validateDeclName(options.name);
     const decl = {
         ...options,
         kind: NodeKind.TypeAliasDecl,
         sourceUrl,
-        type: Lazy.of(() => setParent(options.type(...options.parameters), decl)),
+        type: Lazy.of(() => options.type(...options.parameters)),
     };
     return decl;
 };
@@ -21,21 +20,21 @@ export const TypeAliasDecl = (sourceUrl, options) => {
         kind: NodeKind.TypeAliasDecl,
         sourceUrl,
         parameters: [],
-        type: Lazy.of(() => setParent(options.type(), decl)),
+        type: Lazy.of(() => options.type()),
     };
     return decl;
 };
 export { TypeAliasDecl as TypeAlias };
-export const isTypeAliasDecl = (node) => node.kind === NodeKind.TypeAliasDecl;
+export const isTypeAliasDecl = node => node.kind === NodeKind.TypeAliasDecl;
 export const getNestedDeclarationsInTypeAliasDecl = (addedDecls, decl) => getNestedDeclarations(addedDecls, decl.type.value);
-export const validateTypeAliasDecl = (helpers, decl, args, value) => validate(helpers, resolveTypeArgumentsInType(getTypeArgumentsRecord(decl, args), decl.type.value), value);
-export const resolveTypeArgumentsInTypeAliasDecl = (decl, args) => TypeAliasDecl(decl.sourceUrl, {
+export const validateTypeAliasDecl = ((helpers, decl, args, value) => validateType(helpers, resolveTypeArguments(getTypeArgumentsRecord(decl, args), decl.type.value), value));
+export const resolveTypeArgumentsInTypeAliasDecl = (args, decl) => TypeAliasDecl(decl.sourceUrl, {
     ...decl,
-    type: () => resolveTypeArgumentsInType(getTypeArgumentsRecord(decl, args), decl.type.value),
+    type: () => resolveTypeArguments(args, decl.type.value),
 });
 export const serializeTypeAliasDecl = type => ({
     ...type,
-    type: serializeType(type.type.value),
+    type: serializeNode(type.type.value),
     parameters: type.parameters.map(param => serializeTypeParameter(param)),
 });
-export const getReferencesForTypeAliasDecl = (decl, value) => getReferencesForType(decl.type.value, value);
+export const getReferencesForTypeAliasDecl = (decl, value) => getReferences(decl.type.value, value);

package/dist/src/node/schema/index.d.ts

@@ -11,8 +11,6 @@ export * from "./types/primitives/BooleanType.ts";
 export * from "./types/primitives/DateType.ts";
 export * from "./types/primitives/FloatType.ts";
 export * from "./types/primitives/IntegerType.ts";
-export * from "./types/primitives/NumericType.ts";
-export type * from "./types/primitives/PrimitiveType.ts";
 export * from "./types/primitives/StringType.ts";
 export * from "./types/references/IncludeIdentifierType.ts";
 export * from "./types/references/NestedEntityMapType.ts";

package/dist/src/node/schema/index.js

@@ -11,7 +11,6 @@ export * from "./types/primitives/BooleanType.js";
 export * from "./types/primitives/DateType.js";
 export * from "./types/primitives/FloatType.js";
 export * from "./types/primitives/IntegerType.js";
-export * from "./types/primitives/NumericType.js";
 export * from "./types/primitives/StringType.js";
 export * from "./types/references/IncludeIdentifierType.js";
 export * from "./types/references/NestedEntityMapType.js";

package/dist/src/node/schema/types/Type.d.ts

@@ -1,52 +1,29 @@
-import type { Decl } from "../declarations/Declaration.ts";
-import type { BaseNode, GetReferences, Serializer } from "../Node.ts";
-import type { Validator } from "../validation/type.ts";
-import type { ArrayType, SerializedArrayType } from "./generic/ArrayType.ts";
-import type { EnumType, SerializedEnumType } from "./generic/EnumType.ts";
-import type { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "./generic/ObjectType.ts";
-import type { BooleanType, SerializedBooleanType } from "./primitives/BooleanType.ts";
-import type { DateType, SerializedDateType } from "./primitives/DateType.ts";
-import type { FloatType, SerializedFloatType } from "./primitives/FloatType.ts";
-import type { IntegerType, SerializedIntegerType } from "./primitives/IntegerType.ts";
-import type { PrimitiveType, SerializedPrimitiveType } from "./primitives/PrimitiveType.ts";
-import type { SerializedStringType, StringType } from "./primitives/StringType.ts";
-import type { IncludeIdentifierType, SerializedIncludeIdentifierType } from "./references/IncludeIdentifierType.ts";
-import type { NestedEntityMapType, SerializedNestedEntityMapType } from "./references/NestedEntityMapType.ts";
-import type { ReferenceIdentifierType, SerializedReferenceIdentifierType } from "./references/ReferenceIdentifierType.ts";
-import type { SerializedTypeArgumentType, TypeArgumentType } from "./references/TypeArgumentType.ts";
+import type { Decl } from "../index.ts";
+import type { BaseNode } from "../Node.ts";
+import type { ArrayType } from "./generic/ArrayType.ts";
+import type { EnumType } from "./generic/EnumType.ts";
+import type { MemberDecl, ObjectType } from "./generic/ObjectType.ts";
+import type { BooleanType } from "./primitives/BooleanType.ts";
+import type { DateType } from "./primitives/DateType.ts";
+import type { FloatType } from "./primitives/FloatType.ts";
+import type { IntegerType } from "./primitives/IntegerType.ts";
+import type { StringType } from "./primitives/StringType.ts";
+import { type ChildEntitiesType } from "./references/ChildEntitiesType.ts";
+import type { IncludeIdentifierType } from "./references/IncludeIdentifierType.ts";
+import type { NestedEntityMapType } from "./references/NestedEntityMapType.ts";
+import type { ReferenceIdentifierType } from "./references/ReferenceIdentifierType.ts";
+import type { TypeArgumentType } from "./references/TypeArgumentType.ts";
 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 Type = BooleanType | DateType | FloatType | IntegerType | StringType | ArrayType | ObjectType | TypeArgumentType | ReferenceIdentifierType | IncludeIdentifierType | NestedEntityMapType | EnumType | ChildEntitiesType;
+export declare function walkTypeNodeTree(callbackFn: (type: Type, parentTypes: Type[], parentDecl: Decl) => void, type: Type, parentTypes: Type[], parentDecl: Decl): 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;
+} : 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 ? string : T extends ChildEntitiesType ? string[] : 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;
-/**
- * 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 declare const setParent: <T extends BaseType>(type: Omit<T, "parent">, parentNode: Type | Decl) => T;
-export declare const removeParentKey: <T extends BaseType>(type: T) => Omit<T, "parent">;
+}> : T extends string ? StringType : T extends number ? FloatType : T extends boolean ? BooleanType : T extends Date ? DateType : never;
 export declare const findTypeAtPath: (type: Type, path: string[]) => Type | undefined;
-export declare const serializeType: Serializer<Type, SerializedType>;
-export declare const getReferencesForType: GetReferences<Type>;
 /**
  * Format the structure of a value to always look the same when serialized as JSON.
  */