tsondb 0.5.18 → 0.6.0

package/dist/src/bin/tsondb.js

@@ -84,7 +84,7 @@ switch (passedArguments.command.name) {
         break;
     case "serve":
         debug(`running command: serve`);
-        await serve(config.schema, config.dataRootPath, config.serverOptions);
+        await serve(config.schema, config.dataRootPath, config.defaultLocales, config.homeLayoutSections, config.serverOptions);
         break;
     case "validate":
         debug(`running command: validate`);

package/dist/src/index.d.ts

@@ -1,2 +1,2 @@
+export type { Config } from "./node/config.ts";
 export * from "./node/index.ts";
-export type { Config } from "./shared/config.ts";

package/dist/src/node/config.d.ts

@@ -0,0 +1,20 @@
+import type { Output } from "../shared/output.ts";
+import type { EntityDecl } from "./schema/index.ts";
+import type { Schema } from "./schema/Schema.ts";
+export type Config = {
+    serverOptions?: ServerOptions;
+    schema: Schema;
+    outputs: Output[];
+    defaultLocales: string[];
+    dataRootPath: string;
+    homeLayoutSections?: HomeLayoutSection[];
+};
+export type ServerOptions = {
+    port: number;
+};
+export type HomeLayoutSection = {
+    title: string;
+    comment?: string;
+    entities: EntityDecl[];
+};
+export declare const validateConfig: (config: Config) => void;

package/dist/src/node/config.js

@@ -0,0 +1,5 @@
+export const validateConfig = (config) => {
+    if (config.defaultLocales.length === 0) {
+        throw new Error("At least one default locale must be specified in the config.");
+    }
+};

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

@@ -1,4 +1,5 @@
 import type { Output } from "../shared/output.ts";
+import type { HomeLayoutSection } from "./config.ts";
 import { type Schema } from "./schema/Schema.ts";
 import type { ServerOptions } from "./server/index.ts";
 export declare const generateOutputs: (schema: Schema, outputs: Output[]) => Promise<void>;
@@ -8,7 +9,7 @@ type ValidationOptions = {
 };
 export declare const validate: (schema: Schema, dataRootPath: string, options?: Partial<ValidationOptions>) => Promise<void>;
 export declare const generateAndValidate: (schema: Schema, outputs: Output[], dataRootPath: string, validationOptions?: Partial<ValidationOptions>) => Promise<void>;
-export declare const serve: (schema: Schema, dataRootPath: string, serverOptions?: Partial<ServerOptions>) => Promise<void>;
-export declare const generateValidateAndServe: (schema: Schema, outputs: Output[], dataRootPath: string, serverOptions?: Partial<ServerOptions>, validationOptions?: Partial<ValidationOptions>) => Promise<void>;
+export declare const serve: (schema: Schema, dataRootPath: string, defaultLocales: string[], homeLayoutSections?: HomeLayoutSection[], serverOptions?: Partial<ServerOptions>) => Promise<void>;
+export declare const generateValidateAndServe: (schema: Schema, outputs: Output[], dataRootPath: string, defaultLocales: string[], homeLayoutSections?: HomeLayoutSection[], serverOptions?: Partial<ServerOptions>, validationOptions?: Partial<ValidationOptions>) => Promise<void>;
 export declare const format: (schema: Schema, dataRootPath: string) => Promise<void>;
 export {};

package/dist/src/node/index.js

@@ -1,5 +1,5 @@
 import Debug from "debug";
-import { mkdir, writeFile } from "fs/promises";
+import { mkdir } from "fs/promises";
 import { join, sep } from "path";
 import { styleText } from "util";
 import { parallelizeErrors } from "../shared/utils/validation.js";
@@ -8,7 +8,8 @@ import { createValidators } from "./schema/Node.js";
 import { getEntities } from "./schema/Schema.js";
 import { createServer } from "./server/index.js";
 import { countErrors, getErrorMessageForDisplay, wrapErrorsIfAny } from "./utils/error.js";
-import { formatInstance, getInstancesByEntityName } from "./utils/instances.js";
+import { getFileNameForId, writeInstance } from "./utils/files.js";
+import { getInstancesByEntityName } from "./utils/instances.js";
 const debug = Debug("tsondb:jsapi");
 const prepareFolders = async (dataRootPath, entities) => {
     await mkdir(dataRootPath, { recursive: true });
@@ -29,10 +30,11 @@ const _validate = (dataRootPath, entities, instancesByEntityName, options = {})
             throw new Error(`Entity "${onlyEntity}" not found in schema`);
         }
     }
+    const validationHelpers = createValidators(instancesByEntityName, true, checkReferentialIntegrity);
     const errors = (checkOnlyEntities.length > 0
         ? entities.filter(entity => checkOnlyEntities.includes(entity.name))
         : entities)
-        .flatMap(entity => parallelizeErrors(instancesByEntityName[entity.name]?.map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${dataRootPath}${sep}${styleText("bold", join(entity.name, instance.fileName))}"`)}`, validateEntityDecl(createValidators(instancesByEntityName, true, checkReferentialIntegrity), entity, instance.content))) ?? []))
+        .flatMap(entity => parallelizeErrors(instancesByEntityName[entity.name]?.map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${dataRootPath}${sep}${styleText("bold", join(entity.name, getFileNameForId(instance.id)))}"`)}`, validateEntityDecl(validationHelpers, entity, instance.content))) ?? []))
         .toSorted((a, b) => a.message.localeCompare(b.message));
     if (errors.length === 0) {
         debug("All entities are valid");
@@ -55,21 +57,24 @@ export const generateAndValidate = async (schema, outputs, dataRootPath, validat
     const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
     _validate(dataRootPath, entities, instancesByEntityName, validationOptions);
 };
-export const serve = async (schema, dataRootPath, serverOptions) => {
+export const serve = async (schema, dataRootPath, defaultLocales, homeLayoutSections, serverOptions) => {
+    if (defaultLocales.length === 0) {
+        throw new Error("At least one default locale must be specified to start the server.");
+    }
     const entities = getEntities(schema);
     await prepareFolders(dataRootPath, entities);
     debug("prepared folders");
     const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
     debug("loaded instances");
-    await createServer(schema, dataRootPath, instancesByEntityName, serverOptions);
+    await createServer(schema, dataRootPath, instancesByEntityName, defaultLocales, homeLayoutSections, serverOptions);
 };
-export const generateValidateAndServe = async (schema, outputs, dataRootPath, serverOptions, validationOptions) => {
+export const generateValidateAndServe = async (schema, outputs, dataRootPath, defaultLocales, homeLayoutSections, serverOptions, validationOptions) => {
     await generateOutputs(schema, outputs);
     const entities = getEntities(schema);
     await prepareFolders(dataRootPath, entities);
     const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
     _validate(dataRootPath, entities, instancesByEntityName, validationOptions);
-    await createServer(schema, dataRootPath, instancesByEntityName, serverOptions);
+    await createServer(schema, dataRootPath, instancesByEntityName, defaultLocales, homeLayoutSections, serverOptions);
 };
 export const format = async (schema, dataRootPath) => {
     const entities = getEntities(schema);
@@ -80,7 +85,7 @@ export const format = async (schema, dataRootPath) => {
         const entity = entities.find(entity => entity.name === entityName);
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         for (const instance of instancesByEntityName[entityName]) {
-            await writeFile(join(dataRootPath, entityName, instance.fileName), formatInstance(entity, instance.content), { encoding: "utf-8" });
+            await writeInstance(dataRootPath, entity, instance.id, instance.content);
         }
     }
 };

package/dist/src/node/renderers/jsonschema/render.d.ts

@@ -1,4 +1,4 @@
-import type { Decl } from "../../schema/declarations/Declaration.ts";
+import { type Decl } from "../../schema/declarations/Declaration.ts";
 export type JsonSchemaRendererOptions = {
     format: "minified" | "tabs" | {
         kind: "spaces";

package/dist/src/node/renderers/jsonschema/render.js

@@ -1,11 +1,13 @@
 import { dirname, relative } from "node:path";
 import { discriminatorKey } from "../../../shared/enum.js";
 import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
+import { asDecl } from "../../schema/declarations/Declaration.js";
 import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/declarations/EntityDecl.js";
 import { TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
+import { ArrayType } from "../../schema/types/generic/ArrayType.js";
 import { isNestedEntityMapType } from "../../schema/types/references/NestedEntityMapType.js";
-import { getParentDecl } from "../../schema/types/Type.js";
+import { ReferenceIdentifierType } from "../../schema/types/references/ReferenceIdentifierType.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
 const defaultIndentation = 2;
 const defaultOptions = {
@@ -74,7 +76,7 @@ const renderReferenceIdentifierType = (_options, type) => ({
     $ref: `#/$defs/${type.entity.name}_ID`,
 });
 const renderIncludeIdentifierType = (options, type) => {
-    const sourceUrl = getParentDecl(type)?.sourceUrl ?? "";
+    const sourceUrl = options.parentDecl?.sourceUrl ?? "";
     const filePath = options.preserveFiles && sourceUrl !== type.reference.sourceUrl
         ? ensureSpecialDirStart(relative(dirname(sourceUrl), type.reference.sourceUrl))
         : "";
@@ -101,6 +103,7 @@ const renderEnumType = (options, type) => ({
         required: [discriminatorKey, ...(caseDef.type === null ? [] : [caseName])],
     })),
 });
+const renderChildEntitiesType = (options, type) => renderType(options, ArrayType(ReferenceIdentifierType(type.entity), { uniqueItems: true }));
 const renderType = (options, type) => {
     switch (type.kind) {
         case NodeKind.ArrayType:
@@ -127,6 +130,8 @@ const renderType = (options, type) => {
             return renderNestedEntityMapType(options, type);
         case NodeKind.EnumType:
             return renderEnumType(options, type);
+        case NodeKind.ChildEntitiesType:
+            return renderChildEntitiesType(options, type);
         default:
             return assertExhaustive(type, "Unknown type");
     }
@@ -149,11 +154,11 @@ const renderTypeAliasDecl = (options, decl) => ({
 const renderDecl = (options, decl) => {
     switch (decl.kind) {
         case NodeKind.EntityDecl:
-            return renderEntityDecl(options, decl);
+            return renderEntityDecl({ ...options, parentDecl: decl }, decl);
         case NodeKind.EnumDecl:
-            return renderEnumDecl(options, decl);
+            return renderEnumDecl({ ...options, parentDecl: decl }, decl);
         case NodeKind.TypeAliasDecl:
-            return renderTypeAliasDecl(options, decl);
+            return renderTypeAliasDecl({ ...options, parentDecl: decl }, decl);
         default:
             return assertExhaustive(decl, "Unknown declaration");
     }
@@ -162,14 +167,14 @@ const renderDeclarations = (options, declarations) => Object.fromEntries(declara
 export const render = (options = defaultOptions, declarations) => {
     const finalOptions = { ...defaultOptions, ...options };
     return JSON.stringify({
-        $defs: renderDeclarations(finalOptions, flatMapAuxiliaryDecls((node, existingDecls) => {
+        $defs: renderDeclarations(finalOptions, flatMapAuxiliaryDecls((parentNodes, node, existingDecls) => {
             if (isNestedEntityMapType(node)) {
                 if (existingDecls.some(decl => decl.name === node.name)) {
                     // this may happen when a nested entity map is defined in a generic declaration and the generic declaration is used multiple times
                     // TODO: circumvent by defining the nested entity declaration outside the generic declaration
                     return undefined;
                 }
-                return TypeAliasDecl(getParentDecl(node)?.sourceUrl ?? "", {
+                return TypeAliasDecl(asDecl(parentNodes[0])?.sourceUrl ?? "", {
                     name: node.name,
                     comment: node.comment,
                     type: () => node.type.value,

package/dist/src/node/renderers/ts/render.d.ts

@@ -1,4 +1,4 @@
-import type { Decl } from "../../schema/declarations/Declaration.ts";
+import { type Decl } from "../../schema/declarations/Declaration.ts";
 export type TypeScriptRendererOptions = {
     indentation: number;
     objectTypeKeyword: "interface" | "type";

package/dist/src/node/renderers/ts/render.js

@@ -4,12 +4,14 @@ import { discriminatorKey } from "../../../shared/enum.js";
 import { unique } from "../../../shared/utils/array.js";
 import { toCamelCase } from "../../../shared/utils/string.js";
 import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
+import { asDecl } from "../../schema/declarations/Declaration.js";
 import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/declarations/EntityDecl.js";
 import { TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
+import { ArrayType } from "../../schema/types/generic/ArrayType.js";
 import { isObjectType } from "../../schema/types/generic/ObjectType.js";
 import { isNestedEntityMapType } from "../../schema/types/references/NestedEntityMapType.js";
-import { getParentDecl } from "../../schema/types/Type.js";
+import { ReferenceIdentifierType } from "../../schema/types/references/ReferenceIdentifierType.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
 import { combineSyntaxes, indent, prefixLines, syntax } from "../../utils/render.js";
 const defaultOptions = {
@@ -38,7 +40,8 @@ const renderObjectType = (options, type) => {
 };
 const renderBooleanType = (_options, _type) => syntax `boolean`;
 const renderDateType = (_options, _type) => syntax `Date`;
-const renderNumericType = (_options, _type) => syntax `number`;
+const renderFloatType = (_options, _type) => syntax `number`;
+const renderIntegerType = (_options, _type) => syntax `number`;
 const renderStringType = (_options, _type) => syntax `string`;
 const renderTypeArgumentType = (_options, type) => syntax `${type.argument.name}`;
 const renderReferenceIdentifierType = (_options, type) => [
@@ -55,6 +58,7 @@ const renderNestedEntityMapType = (options, type) => wrapAsObject(options, synta
 const renderEnumType = (options, type) => combineSyntaxes(Object.entries(type.values).map(([caseName, caseDef]) => indent(options.indentation, 1, syntax `${EOL}| {${EOL}${indent(options.indentation, 1, syntax `${discriminatorKey}: "${caseName}"${caseDef.type === null
     ? ""
     : syntax `${EOL}${caseName}: ${renderType(options, caseDef.type)}`}`)}${EOL}}`)));
+const renderChildEntitiesType = (options, type) => renderType(options, ArrayType(ReferenceIdentifierType(type.entity), { uniqueItems: true }));
 const renderType = (options, type) => {
     switch (type.kind) {
         case NodeKind.ArrayType:
@@ -66,9 +70,9 @@ const renderType = (options, type) => {
         case NodeKind.DateType:
             return renderDateType(options, type);
         case NodeKind.FloatType:
-            return renderNumericType(options, type);
+            return renderFloatType(options, type);
         case NodeKind.IntegerType:
-            return renderNumericType(options, type);
+            return renderIntegerType(options, type);
         case NodeKind.StringType:
             return renderStringType(options, type);
         case NodeKind.TypeArgumentType:
@@ -81,6 +85,8 @@ const renderType = (options, type) => {
             return renderNestedEntityMapType(options, type);
         case NodeKind.EnumType:
             return renderEnumType(options, type);
+        case NodeKind.ChildEntitiesType:
+            return renderChildEntitiesType(options, type);
         default:
             return assertExhaustive(type, "Unknown type");
     }
@@ -119,9 +125,9 @@ const renderImports = (currentUrl, imports) => {
 };
 export const render = (options = defaultOptions, declarations) => {
     const finalOptions = { ...defaultOptions, ...options };
-    const [imports, content] = renderDeclarations(finalOptions, flatMapAuxiliaryDecls(node => {
+    const [imports, content] = renderDeclarations(finalOptions, flatMapAuxiliaryDecls((parentNodes, node) => {
         if (isNestedEntityMapType(node)) {
-            return TypeAliasDecl(getParentDecl(node)?.sourceUrl ?? "", {
+            return TypeAliasDecl(asDecl(parentNodes[0])?.sourceUrl ?? "", {
                 name: node.name,
                 comment: node.comment,
                 type: () => node.type.value,

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

@@ -1,32 +1,50 @@
+import type { SerializedEntityDecl } from "../../shared/schema/declarations/EntityDecl.ts";
+import type { SerializedEnumDecl } from "../../shared/schema/declarations/EnumDecl.ts";
+import type { SerializedTypeAliasDecl } from "../../shared/schema/declarations/TypeAliasDecl.ts";
+import { NodeKind } from "../../shared/schema/Node.ts";
+import type { SerializedTypeParameter } from "../../shared/schema/TypeParameter.ts";
+import type { SerializedArrayType } from "../../shared/schema/types/ArrayType.ts";
+import type { SerializedBooleanType } from "../../shared/schema/types/BooleanType.ts";
+import type { SerializedChildEntitiesType } from "../../shared/schema/types/ChildEntitiesType.ts";
+import type { SerializedDateType } from "../../shared/schema/types/DateType.ts";
+import type { SerializedEnumCaseDecl, SerializedEnumType } from "../../shared/schema/types/EnumType.ts";
+import type { SerializedFloatType } from "../../shared/schema/types/FloatType.ts";
+import type { SerializedIncludeIdentifierType } from "../../shared/schema/types/IncludeIdentifierType.ts";
+import type { SerializedIntegerType } from "../../shared/schema/types/IntegerType.ts";
+import type { SerializedNestedEntityMapType } from "../../shared/schema/types/NestedEntityMapType.ts";
+import type { SerializedMemberDecl, SerializedObjectType } from "../../shared/schema/types/ObjectType.ts";
+import type { SerializedReferenceIdentifierType } from "../../shared/schema/types/ReferenceIdentifierType.ts";
+import type { SerializedStringType } from "../../shared/schema/types/StringType.ts";
+import type { SerializedTypeArgumentType } from "../../shared/schema/types/TypeArgumentType.ts";
 import type { InstancesByEntityName } from "../../shared/utils/instances.ts";
-import type { Decl } from "./declarations/Declaration.ts";
+import { type Decl, type IncludableDeclP } from "./declarations/Declaration.ts";
+import { type EntityDecl } from "./declarations/EntityDecl.ts";
+import { type EnumDecl } from "./declarations/EnumDecl.ts";
+import { type TypeAliasDecl } from "./declarations/TypeAliasDecl.ts";
+import { type TypeParameter } from "./TypeParameter.ts";
+import { type ArrayType } from "./types/generic/ArrayType.ts";
+import { type EnumCaseDecl, type EnumType } from "./types/generic/EnumType.ts";
+import { type MemberDecl, type ObjectType } from "./types/generic/ObjectType.ts";
+import { type BooleanType } from "./types/primitives/BooleanType.ts";
+import { type DateType } from "./types/primitives/DateType.ts";
+import { type FloatType } from "./types/primitives/FloatType.ts";
+import { type IntegerType } from "./types/primitives/IntegerType.ts";
+import { type StringType } from "./types/primitives/StringType.ts";
+import { type ChildEntitiesType } from "./types/references/ChildEntitiesType.ts";
+import { type IncludeIdentifierType } from "./types/references/IncludeIdentifierType.ts";
+import { type NestedEntityMapType } from "./types/references/NestedEntityMapType.ts";
+import { type ReferenceIdentifierType } from "./types/references/ReferenceIdentifierType.ts";
+import { type TypeArgumentType } from "./types/references/TypeArgumentType.ts";
 import type { Type } from "./types/Type.ts";
-export interface NodeKind {
-    EntityDecl: "EntityDecl";
-    EnumDecl: "EnumDecl";
-    EnumCaseDecl: "EnumCaseDecl";
-    TypeAliasDecl: "TypeAliasDecl";
-    MemberDecl: "MemberDecl";
-    ArrayType: "ArrayType";
-    ObjectType: "ObjectType";
-    BooleanType: "BooleanType";
-    FloatType: "FloatType";
-    IntegerType: "IntegerType";
-    StringType: "StringType";
-    DateType: "DateType";
-    TypeArgumentType: "TypeArgumentType";
-    GenericParameter: "GenericParameter";
-    ReferenceIdentifierType: "ReferenceIdentifierType";
-    IncludeIdentifierType: "IncludeIdentifierType";
-    NestedEntityMapType: "NestedEntityMapType";
-    EnumType: "EnumType";
-}
-export declare const NodeKind: NodeKind;
-export interface BaseNode {
-    kind: (typeof NodeKind)[keyof typeof NodeKind];
-}
-export type Node = Decl | Type;
-export declare const flatMapAuxiliaryDecls: (callbackFn: (node: Node, existingDecls: Decl[]) => (Decl | undefined)[] | Decl | undefined, declarations: readonly Decl[]) => Decl[];
+export type { BaseNode } from "../../shared/schema/Node.ts";
+export { NodeKind };
+export type Node = Decl | Type | TypeParameter;
+export declare const reduceNodes: <R>(reducer: (parentNodes: Node[], node: Node, collectedResults: R[]) => R[], nodes: readonly Node[], options?: {
+    initialResults?: R[];
+    followIncludes?: boolean;
+    followChildEntities?: boolean;
+}) => R[];
+export declare const flatMapAuxiliaryDecls: (callbackFn: (parentNodes: Node[], node: Node, existingDecls: Decl[]) => (Decl | undefined)[] | Decl | undefined, declarations: readonly Decl[]) => Decl[];
 export type IdentifierToCheck = {
     name: string;
     value: unknown;
@@ -36,5 +54,58 @@ export interface Validators {
     checkReferentialIntegrity: (identifier: IdentifierToCheck) => Error[];
 }
 export declare const createValidators: (instancesByEntityName: InstancesByEntityName, useStyling: boolean, checkReferentialIntegrity?: boolean) => Validators;
-export type Serializer<T, U> = (node: T) => U;
-export type GetReferences<T extends Node> = (node: T, value: unknown) => string[];
+export type Predicate<T extends Node> = (node: Node) => node is T;
+export type GetNestedDeclarations<T extends Node = Node> = (addedDecls: Decl[], node: T) => Decl[];
+export declare const getNestedDeclarations: GetNestedDeclarations;
+export type Validator<T extends Node = Node> = (helpers: Validators, node: T, value: unknown) => Error[];
+export type ValidatorOfParamDecl<T extends Node = Node> = (helpers: Validators, node: T, typeArgs: Type[], value: unknown) => Error[];
+export declare const validateDecl: ValidatorOfParamDecl<Decl>;
+export declare const validateType: Validator<Type>;
+export type NodeWithResolvedTypeArguments<T extends Node | null> = T extends BooleanType | DateType | FloatType | IntegerType | StringType | ReferenceIdentifierType ? T : T extends EntityDecl<infer N, infer P, infer FK> ? EntityDecl<N, {
+    [K in keyof P]: P[K] extends MemberDecl<infer PT, infer R> ? MemberDecl<NodeWithResolvedTypeArguments<PT>, R> : never;
+}, FK> : T extends EnumDecl<infer N, infer V, TypeParameter[]> ? EnumDecl<N, {
+    [K in keyof V]: V[K] extends EnumCaseDecl<infer CT> ? EnumCaseDecl<NodeWithResolvedTypeArguments<CT>> : never;
+}, [
+]> : T extends TypeAliasDecl<infer N, infer U, TypeParameter[]> ? TypeAliasDecl<N, NodeWithResolvedTypeArguments<U>, []> : T extends ArrayType<infer I> ? ArrayType<NodeWithResolvedTypeArguments<I>> : T extends EnumType<infer V> ? EnumType<{
+    [K in keyof V]: V[K] extends EnumCaseDecl<infer CT> ? EnumCaseDecl<NodeWithResolvedTypeArguments<CT>> : never;
+}> : T extends ObjectType<infer P> ? ObjectType<{
+    [K in keyof P]: P[K] extends MemberDecl<infer PT, infer R> ? MemberDecl<NodeWithResolvedTypeArguments<PT>, R> : never;
+}> : T extends TypeArgumentType ? Type : T extends IncludeIdentifierType<[], IncludableDeclP<[]>> ? T : T extends IncludeIdentifierType ? Type : T extends NestedEntityMapType<infer N, infer P> ? NestedEntityMapType<N, {
+    [K in keyof P]: P[K] extends MemberDecl<infer PT, infer R> ? MemberDecl<NodeWithResolvedTypeArguments<PT>, R> : never;
+}> : T extends TypeParameter<infer N, infer C> ? TypeParameter<N, NodeWithResolvedTypeArguments<C>> : T extends ChildEntitiesType<infer E> ? ChildEntitiesType<E> : T extends null ? null : never;
+export type TypeArgumentsResolver<T extends Node = Node> = (args: Record<string, Type>, node: T) => NodeWithResolvedTypeArguments<T>;
+export declare const resolveTypeArguments: <T extends Node = Node>(args: Record<string, Type>, node: T) => NodeWithResolvedTypeArguments<T>;
+export type SerializedNodeMap = {
+    [NodeKind.EntityDecl]: [EntityDecl, SerializedEntityDecl];
+    [NodeKind.EnumDecl]: [EnumDecl, SerializedEnumDecl];
+    [NodeKind.TypeAliasDecl]: [TypeAliasDecl, SerializedTypeAliasDecl];
+    [NodeKind.ArrayType]: [ArrayType, SerializedArrayType];
+    [NodeKind.ObjectType]: [ObjectType, SerializedObjectType];
+    [NodeKind.BooleanType]: [BooleanType, SerializedBooleanType];
+    [NodeKind.DateType]: [DateType, SerializedDateType];
+    [NodeKind.FloatType]: [FloatType, SerializedFloatType];
+    [NodeKind.IntegerType]: [IntegerType, SerializedIntegerType];
+    [NodeKind.StringType]: [StringType, SerializedStringType];
+    [NodeKind.TypeArgumentType]: [TypeArgumentType, SerializedTypeArgumentType];
+    [NodeKind.ReferenceIdentifierType]: [ReferenceIdentifierType, SerializedReferenceIdentifierType];
+    [NodeKind.IncludeIdentifierType]: [IncludeIdentifierType, SerializedIncludeIdentifierType];
+    [NodeKind.NestedEntityMapType]: [NestedEntityMapType, SerializedNestedEntityMapType];
+    [NodeKind.EnumType]: [EnumType, SerializedEnumType];
+    [NodeKind.TypeParameter]: [TypeParameter, SerializedTypeParameter];
+    [NodeKind.ChildEntitiesType]: [ChildEntitiesType, SerializedChildEntitiesType];
+};
+export type SerializedTypeParameters<T extends TypeParameter[]> = {
+    [K in keyof T]: T[K] extends TypeParameter<infer N, infer C> ? SerializedTypeParameter<N, C extends Type ? Serialized<C> : undefined> : never;
+};
+export type SerializedMemberDeclObject<T extends Record<string, MemberDecl>> = {
+    [K in keyof T]: T[K] extends MemberDecl<infer CT, infer R> ? SerializedMemberDecl<Serialized<CT>, R> : never;
+};
+export type SerializedEnumCaseDeclObject<T extends Record<string, EnumCaseDecl>> = {
+    [K in keyof T]: T[K] extends EnumCaseDecl<infer CT> ? SerializedEnumCaseDecl<CT extends Type ? Serialized<CT> : null> : never;
+};
+export type Serialized<T extends Node> = T extends EntityDecl<infer Name, infer T, infer FK> ? SerializedEntityDecl<Name, SerializedMemberDeclObject<T>, FK> : T extends EnumDecl<infer Name, infer T, infer Params> ? SerializedEnumDecl<Name, SerializedEnumCaseDeclObject<T>, SerializedTypeParameters<Params>> : T extends TypeAliasDecl<infer Name, infer T, infer Params> ? SerializedTypeAliasDecl<Name, Serialized<T>, SerializedTypeParameters<Params>> : T extends ArrayType<infer T> ? SerializedArrayType<Serialized<T>> : T extends ObjectType<infer T> ? SerializedObjectType<SerializedMemberDeclObject<T>> : T extends BooleanType ? SerializedBooleanType : T extends DateType ? SerializedDateType : T extends FloatType ? SerializedFloatType : T extends IntegerType ? SerializedIntegerType : T extends StringType ? SerializedStringType : T extends TypeArgumentType<infer T> ? SerializedTypeArgumentType<Serialized<T>> : T extends ReferenceIdentifierType ? SerializedReferenceIdentifierType : T extends IncludeIdentifierType<infer Params> ? SerializedIncludeIdentifierType<SerializedTypeParameters<Params>> : T extends NestedEntityMapType<infer Name, infer T> ? SerializedNestedEntityMapType<Name, SerializedMemberDeclObject<T>> : T extends EnumType<infer T> ? SerializedEnumType<SerializedEnumCaseDeclObject<T>> : T extends TypeParameter<infer N, infer C> ? SerializedTypeParameter<N, C extends Type ? Serialized<C> : undefined> : T extends ChildEntitiesType ? SerializedChildEntitiesType : never;
+export type SerializedOf<T extends Node> = SerializedNodeMap[T["kind"]][1];
+export type Serializer<T extends Node = Node> = (node: T) => Serialized<T>;
+export declare const serializeNode: <T extends Node>(node: T) => Serialized<T>;
+export type GetReferences<T extends Node = Node> = (node: T, value: unknown) => string[];
+export declare const getReferences: GetReferences;