tsondb 0.5.18 → 0.6.0

package/dist/src/node/utils/displayName.js

@@ -1,12 +1,13 @@
 import { serializeEntityDecl } from "../../node/schema/index.js";
-import { getSerializedDisplayNameFromEntityInstance } from "../../shared/utils/displayName.js";
-export const getDisplayNameFromEntityInstance = (entity, instance, getInstanceById, locales = [], defaultName = "", useCustomizer = true) => {
+import { getSerializedDisplayNameFromEntityInstance, } from "../../shared/utils/displayName.js";
+export const getDisplayNameFromEntityInstance = (entity, instance, getInstanceById, locales, defaultName = "", useCustomizer = true) => {
     if (useCustomizer && entity.displayNameCustomizer) {
-        return entity.displayNameCustomizer(instance, getDisplayNameFromEntityInstance(entity, instance, getInstanceById, locales, defaultName, false), id => getInstanceById(id)?.instance.content, id => {
+        const calculatedName = getDisplayNameFromEntityInstance(entity, instance, getInstanceById, locales, defaultName, false);
+        return entity.displayNameCustomizer(instance, calculatedName.name, calculatedName.localeId, id => getInstanceById(id)?.instance.content, id => {
             const result = getInstanceById(id);
             if (result) {
                 const { entity, instance } = result;
-                return getDisplayNameFromEntityInstance(entity, instance.content, getInstanceById, locales, id);
+                return getDisplayNameFromEntityInstance(entity, instance.content, getInstanceById, locales, id).name;
             }
             else {
                 return undefined;

package/dist/src/node/utils/files.d.ts

@@ -0,0 +1,5 @@
+import type { EntityDecl } from "../schema/index.ts";
+export declare const getFileNameForId: (id: string) => string;
+export declare const getPathToInstance: (dataRoot: string, entityName: string, id: string) => string;
+export declare const writeInstance: (dataRoot: string, entity: EntityDecl, id: string, instance: unknown) => Promise<void>;
+export declare const deleteInstance: (dataRoot: string, entityName: string, id: string) => Promise<void>;

package/dist/src/node/utils/files.js

@@ -0,0 +1,9 @@
+import { rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { formatInstance } from "./instances.js";
+export const getFileNameForId = (id) => `${id}.json`;
+export const getPathToInstance = (dataRoot, entityName, id) => join(dataRoot, entityName, getFileNameForId(id));
+export const writeInstance = (dataRoot, entity, id, instance) => writeFile(getPathToInstance(dataRoot, entity.name, id), formatInstance(entity, instance), {
+    encoding: "utf-8",
+});
+export const deleteInstance = (dataRoot, entityName, id) => rm(getPathToInstance(dataRoot, entityName, id));

package/dist/src/node/utils/instanceOperations.d.ts

@@ -0,0 +1,14 @@
+import type { InstancesByEntityName } from "../../shared/utils/instances.ts";
+import { type Result } from "../../shared/utils/result.ts";
+import type { EntityDecl } from "../schema/declarations/EntityDecl.js";
+import { type ReferencesToInstances } from "./references.ts";
+export declare const createNewId: () => string;
+export declare const checkCreateInstancePossible: (localeEntity: EntityDecl | undefined, instancesByEntityName: InstancesByEntityName, entity: EntityDecl, instanceContent: unknown, customId: unknown) => Result<string, [code: number, message: string]>;
+export declare const createInstance: (dataRoot: string, localeEntity: EntityDecl | undefined, instancesByEntityName: InstancesByEntityName, entity: EntityDecl, instanceContent: unknown, customId: unknown) => Promise<Result<string, [code: number, message: string]>>;
+export declare const checkUpdateInstancePossible: (instancesByEntityName: InstancesByEntityName, entity: EntityDecl, instanceContent: unknown) => Result<void, [code: number, message: string]>;
+export declare const checkCreateNonLocaleInstancePossible: (instancesByEntityName: InstancesByEntityName, entity: EntityDecl, instanceContent: unknown) => Result<void, [code: number, message: string]>;
+export declare const unsafeWriteInstance: (dataRoot: string, entity: EntityDecl, instanceId: string, instanceContent: unknown) => Promise<Result<string, [code: number, message: string]>>;
+export declare const updateInstance: (dataRoot: string, instancesByEntityName: InstancesByEntityName, entity: EntityDecl, instanceId: string, instanceContent: unknown) => Promise<Result<string, [code: number, message: string]>>;
+export declare const checkDeleteInstancePossible: (referencesToInstances: ReferencesToInstances, instanceId: string) => Result<void, [code: number, message: string]>;
+export declare const unsafeDeleteInstance: (dataRoot: string, entityName: string, instanceId: string) => Promise<Result<string, [code: number, message: string]>>;
+export declare const deleteInstance: (dataRoot: string, referencesToInstances: ReferencesToInstances, entityName: string, instanceId: string) => Promise<Result<string, [code: number, message: string]>>;

package/dist/src/node/utils/instanceOperations.js

@@ -0,0 +1,88 @@
+import { v4 as uuidv4 } from "uuid";
+import { error, isOk, map, ok } from "../../shared/utils/result.js";
+import { createValidators, validateEntityDecl } from "../schema/index.js";
+import { getErrorMessageForDisplay } from "./error.js";
+import * as Files from "./files.js";
+import { isReferencedByOtherInstances } from "./references.js";
+export const createNewId = () => uuidv4();
+export const checkCreateInstancePossible = (localeEntity, instancesByEntityName, entity, instanceContent, customId) => {
+    const newInstanceId = entity === localeEntity ? customId : createNewId();
+    if (typeof newInstanceId !== "string") {
+        return error([400, `New identifier "${String(newInstanceId)}" is not a string`]);
+    }
+    if (localeEntity === entity &&
+        instancesByEntityName[entity.name]?.some(instance => instance.id === newInstanceId)) {
+        return error([400, `Duplicate id "${newInstanceId}" for locale entity`]);
+    }
+    return map(checkUpdateInstancePossible(instancesByEntityName, entity, instanceContent), () => newInstanceId);
+};
+export const createInstance = async (dataRoot, localeEntity, instancesByEntityName, entity, instanceContent, customId) => {
+    const prerequisiteCheckResult = checkCreateInstancePossible(localeEntity, instancesByEntityName, entity, instanceContent, customId);
+    if (isOk(prerequisiteCheckResult)) {
+        const newInstanceId = prerequisiteCheckResult.value;
+        return unsafeWriteInstance(dataRoot, entity, newInstanceId, instanceContent);
+    }
+    else {
+        return prerequisiteCheckResult;
+    }
+};
+export const checkUpdateInstancePossible = (instancesByEntityName, entity, instanceContent) => {
+    const validationErrors = validateEntityDecl(createValidators(instancesByEntityName, false), entity, instanceContent);
+    if (validationErrors.length > 0) {
+        return error([400, validationErrors.map(getErrorMessageForDisplay).join("\n\n")]);
+    }
+    else {
+        return ok();
+    }
+};
+export const checkCreateNonLocaleInstancePossible = checkUpdateInstancePossible;
+export const unsafeWriteInstance = async (dataRoot, entity, instanceId, instanceContent) => {
+    try {
+        await Files.writeInstance(dataRoot, entity, instanceId, instanceContent);
+        return ok(instanceId);
+    }
+    catch (err) {
+        return error([
+            500,
+            `Failed to write instance: ${err instanceof Error ? err.toString() : String(err)}`,
+        ]);
+    }
+};
+export const updateInstance = async (dataRoot, instancesByEntityName, entity, instanceId, instanceContent) => {
+    const prerequisiteCheckResult = checkUpdateInstancePossible(instancesByEntityName, entity, instanceContent);
+    if (isOk(prerequisiteCheckResult)) {
+        return unsafeWriteInstance(dataRoot, entity, instanceId, instanceContent);
+    }
+    else {
+        return prerequisiteCheckResult;
+    }
+};
+export const checkDeleteInstancePossible = (referencesToInstances, instanceId) => {
+    if (isReferencedByOtherInstances(referencesToInstances, instanceId)) {
+        return error([400, "Cannot delete instance that is referenced by other instances"]);
+    }
+    else {
+        return ok();
+    }
+};
+export const unsafeDeleteInstance = async (dataRoot, entityName, instanceId) => {
+    try {
+        await Files.deleteInstance(dataRoot, entityName, instanceId);
+        return ok(instanceId);
+    }
+    catch (err) {
+        return error([
+            500,
+            `Failed to delete instance: ${err instanceof Error ? err.toString() : String(err)}`,
+        ]);
+    }
+};
+export const deleteInstance = async (dataRoot, referencesToInstances, entityName, instanceId) => {
+    const prerequisiteCheckResult = checkDeleteInstancePossible(referencesToInstances, instanceId);
+    if (isOk(prerequisiteCheckResult)) {
+        return unsafeDeleteInstance(dataRoot, entityName, instanceId);
+    }
+    else {
+        return prerequisiteCheckResult;
+    }
+};

package/dist/src/node/utils/instances.d.ts

@@ -1,6 +1,6 @@
 import type { StatusResult } from "simple-git";
 import type { InstancesByEntityName } from "../../shared/utils/instances.ts";
-import type { EntityDecl } from "../schema/declarations/EntityDecl.ts";
+import type { EntityDecl } from "../schema/declarations/EntityDecl.js";
 export declare const getInstancesByEntityName: (dataRoot: string, entities: readonly EntityDecl[]) => Promise<InstancesByEntityName>;
 export declare const attachGitStatusToInstancesByEntityName: (instancesByEntityName: InstancesByEntityName, dataRoot: string, gitRoot: string, gitStatus: StatusResult) => void;
 export declare const formatInstance: (entity: EntityDecl, instanceContent: unknown) => string;

package/dist/src/node/utils/instances.js

@@ -1,22 +1,28 @@
+import child_process from "node:child_process";
 import { readdir, readFile } from "node:fs/promises";
 import { basename, extname, join } from "node:path";
+import { platform } from "node:process";
+import { promisify } from "node:util";
+import { mapAsync } from "../../shared/utils/async.js";
 import { formatValue } from "../schema/index.js";
+import { getFileNameForId } from "./files.js";
 import { getGitFileStatusFromStatusResult } from "./git.js";
-export const getInstancesByEntityName = async (dataRoot, entities) => Object.fromEntries((await Promise.all(entities.map(async (entity) => {
+const exec = promisify(child_process.exec);
+const ulimit = platform === "win32" ? 2048 : Number.parseInt((await exec("ulimit -n")).stdout);
+export const getInstancesByEntityName = async (dataRoot, entities) => Object.fromEntries((await mapAsync(entities, async (entity) => {
     const entityDir = join(dataRoot, entity.name);
     const instanceFileNames = await readdir(entityDir);
-    const instances = await Promise.all(instanceFileNames.map(async (instanceFileName) => ({
-        fileName: instanceFileName,
+    const instances = await mapAsync(instanceFileNames, async (instanceFileName) => ({
         id: basename(instanceFileName, extname(instanceFileName)),
         content: JSON.parse(await readFile(join(entityDir, instanceFileName), "utf-8")),
-    })));
+    }), ulimit);
     return [entity.name, instances];
-}))).toSorted(([a], [b]) => a.localeCompare(b)));
+}, 1)).toSorted(([a], [b]) => a.localeCompare(b)));
 export const attachGitStatusToInstancesByEntityName = (instancesByEntityName, dataRoot, gitRoot, gitStatus) => {
     Object.entries(instancesByEntityName).forEach(([entityName, instances]) => {
         instancesByEntityName[entityName] = instances.map(instanceContainer => ({
             ...instanceContainer,
-            gitStatus: getGitFileStatusFromStatusResult(gitStatus, gitRoot, dataRoot, entityName, instanceContainer.fileName),
+            gitStatus: getGitFileStatusFromStatusResult(gitStatus, gitRoot, dataRoot, entityName, getFileNameForId(instanceContainer.id)),
         }));
     });
 };

package/dist/src/node/utils/references.d.ts

@@ -1,3 +1,4 @@
+import type { SerializedDecl } from "../../shared/schema/declarations/Declaration.ts";
 import type { InstanceContainer } from "../../shared/utils/instances.ts";
 import type { EntityDecl } from "../schema/declarations/EntityDecl.ts";
 /**
@@ -6,5 +7,6 @@ import type { EntityDecl } from "../schema/declarations/EntityDecl.ts";
 export type ReferencesToInstances = {
     [instanceId: string]: string[];
 };
-export declare const getReferencesToInstances: (instancesByEntityName: Record<string, InstanceContainer[]>, entitiesByName: Record<string, EntityDecl>) => ReferencesToInstances;
+export declare const isReferencedByOtherInstances: (referencesToInstances: ReferencesToInstances, instanceId: string, otherInstancesToDelete?: string[]) => boolean;
+export declare const getReferencesToInstances: (instancesByEntityName: Record<string, InstanceContainer[]>, serializedDeclarationsByName: Record<string, SerializedDecl>) => Promise<ReferencesToInstances>;
 export declare const updateReferencesToInstances: (entitiesByName: Record<string, EntityDecl>, referencesToInstances: ReferencesToInstances, entityName: string, instanceId: string, oldInstance: unknown, newInstance: unknown) => ReferencesToInstances;

package/dist/src/node/utils/references.js

@@ -1,33 +1,58 @@
 import Debug from "debug";
+import { resolve } from "node:path";
 import { difference, removeAt } from "../../shared/utils/array.js";
+import { isOk } from "../../shared/utils/result.js";
 import { getReferencesForEntityDecl } from "../schema/declarations/EntityDecl.js";
+import { WorkerPool } from "./workers.js";
 const debug = Debug("tsondb:utils:references");
+export const isReferencedByOtherInstances = (referencesToInstances, instanceId, otherInstancesToDelete) => {
+    const allInstancesToDelete = [instanceId, ...(otherInstancesToDelete ?? [])];
+    return referencesToInstances[instanceId]?.some(ref => allInstancesToDelete.includes(ref)) ?? false;
+};
 const addReference = (acc, reference, instanceId) => ({
     ...acc,
     [reference]: [...(acc[reference] ?? []), instanceId],
 });
 const addReferences = (acc, references, instanceId) => references.reduce((acc1, reference) => addReference(acc1, reference, instanceId), acc);
-const removeReference = (acc, reference, instanceId) => acc[reference]
-    ? {
-        ...acc,
-        [reference]: removeAt(acc[reference], acc[reference].indexOf(instanceId)),
+const mergeReferences = (acc, toMerge) => {
+    for (const instanceId in toMerge) {
+        ;
+        (acc[instanceId] ??= []).push(...(toMerge[instanceId] ?? []));
+    }
+    return acc;
+};
+const removeReference = (acc, reference, instanceId) => {
+    if (acc[reference]) {
+        const index = acc[reference].indexOf(instanceId);
+        if (index > -1) {
+            return {
+                ...acc,
+                [reference]: removeAt(acc[reference], index),
+            };
+        }
     }
-    : acc;
+    return acc;
+};
 const removeReferences = (acc, references, instanceId) => references.reduce((acc1, reference) => removeReference(acc1, reference, instanceId), acc);
-export const getReferencesToInstances = (instancesByEntityName, entitiesByName) => {
+export const getReferencesToInstances = async (instancesByEntityName, serializedDeclarationsByName) => {
+    debug("creating reference worker pool ...");
+    const pool = new WorkerPool(6, resolve(import.meta.dirname, "./referencesWorker.js"), serializedDeclarationsByName);
     debug("collecting references ...");
-    return Object.entries(instancesByEntityName).reduce((acc, [entityName, instances]) => {
-        const entity = entitiesByName[entityName];
-        if (entity) {
-            const refs = instances.reduce((acc1, instance) => {
-                const references = getReferencesForEntityDecl(entity, instance.content);
-                return addReferences(acc1, references, instance.id);
-            }, acc);
-            debug("collected references for entity %s in %d instances", entityName, instances.length);
-            return refs;
-        }
-        return acc;
-    }, {});
+    const separateResults = await Promise.all(Object.entries(instancesByEntityName).map(([entityName, instances]) => new Promise((resolve, reject) => {
+        pool.runTask({ entityName, instances }, result => {
+            if (isOk(result)) {
+                debug("collected references for entity %s in %d instances", entityName, instances.length);
+                resolve(result.value);
+            }
+            else {
+                reject(result.error);
+            }
+        });
+    })));
+    await pool.close();
+    const results = separateResults.reduce(mergeReferences, {});
+    debug("collected references");
+    return results;
 };
 export const updateReferencesToInstances = (entitiesByName, referencesToInstances, entityName, instanceId, oldInstance, newInstance) => {
     const entity = entitiesByName[entityName];

package/dist/src/node/utils/referencesWorker.d.ts

@@ -0,0 +1,5 @@
+import type { InstanceContainer } from "../../shared/utils/instances.ts";
+export type ReferencesWorkerTask = {
+    entityName: string;
+    instances: InstanceContainer[];
+};

package/dist/src/node/utils/referencesWorker.js

@@ -0,0 +1,22 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { getReferencesForSerializedEntityDecl, isSerializedEntityDecl, } from "../../shared/schema/declarations/EntityDecl.js";
+const declarationsByName = workerData;
+const addReference = (acc, reference, instanceId) => ({
+    ...acc,
+    [reference]: [...(acc[reference] ?? []), instanceId],
+});
+const addReferences = (acc, references, instanceId) => references.reduce((acc1, reference) => addReference(acc1, reference, instanceId), acc);
+parentPort?.on("message", (task) => {
+    const entityDecl = declarationsByName[task.entityName];
+    if (!entityDecl) {
+        throw new Error(`entity declaration not found for entity name "${task.entityName}"`);
+    }
+    if (!isSerializedEntityDecl(entityDecl)) {
+        throw new Error(`declaration of name "${task.entityName}" is not an entity declaration`);
+    }
+    const refs = task.instances.reduce((acc, instance) => {
+        const references = getReferencesForSerializedEntityDecl(declarationsByName, entityDecl, instance.content);
+        return addReferences(acc, references, instance.id);
+    }, {});
+    parentPort?.postMessage(refs);
+});

package/dist/src/node/utils/workers.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from "node:events";
+import { type Result } from "../../shared/utils/result.ts";
+type TaskInfoCallback<R> = (result: Result<R, Error>) => void;
+export declare class WorkerPool<T, R, I = undefined> extends EventEmitter {
+    private scriptPath;
+    private workers;
+    private freeWorkers;
+    private tasks;
+    private initialData;
+    constructor(...args: I extends undefined ? [numThreads: number, scriptPath: string, initialData?: I] : [numThreads: number, scriptPath: string, initialData: I]);
+    addNewWorker(): void;
+    runTask(task: T, callback: TaskInfoCallback<R>): void;
+    close(): Promise<number[]>;
+}
+export {};

package/dist/src/node/utils/workers.js

@@ -0,0 +1,90 @@
+import { AsyncResource } from "node:async_hooks";
+import { EventEmitter } from "node:events";
+import { Worker } from "node:worker_threads";
+import { error, ok } from "../../shared/utils/result.js";
+// from https://nodejs.org/api/async_context.html#using-asyncresource-for-a-worker-thread-pool
+const kTaskInfo = Symbol("kTaskInfo");
+const kWorkerFreedEvent = Symbol("kWorkerFreedEvent");
+class WorkerPoolTaskInfo extends AsyncResource {
+    callback;
+    constructor(callback) {
+        super("WorkerPoolTaskInfo");
+        this.callback = callback;
+    }
+    done(result) {
+        this.runInAsyncScope(this.callback, null, result);
+        this.emitDestroy(); // `TaskInfo`s are used only once.
+    }
+}
+export class WorkerPool extends EventEmitter {
+    scriptPath;
+    workers;
+    freeWorkers;
+    tasks;
+    initialData;
+    constructor(...args) {
+        const [numThreads, scriptPath, initialData] = args;
+        super();
+        this.scriptPath = scriptPath;
+        this.workers = [];
+        this.freeWorkers = [];
+        this.tasks = [];
+        this.initialData = initialData;
+        for (let i = 0; i < numThreads; i++) {
+            this.addNewWorker();
+        }
+        // Any time the kWorkerFreedEvent is emitted, dispatch
+        // the next task pending in the queue, if any.
+        this.on(kWorkerFreedEvent, () => {
+            const first = this.tasks.shift();
+            if (first) {
+                const { task, callback } = first;
+                this.runTask(task, callback);
+            }
+        });
+    }
+    addNewWorker() {
+        const worker = new Worker(this.scriptPath, {
+            workerData: this.initialData,
+        });
+        worker.on("message", (result) => {
+            // In case of success: Call the callback that was passed to `runTask`,
+            // remove the `TaskInfo` associated with the Worker, and mark it as free
+            // again.
+            worker[kTaskInfo]?.done(ok(result));
+            worker[kTaskInfo] = null;
+            this.freeWorkers.push(worker);
+            this.emit(kWorkerFreedEvent);
+        });
+        worker.on("error", err => {
+            // In case of an uncaught exception: Call the callback that was passed to
+            // `runTask` with the error.
+            if (worker[kTaskInfo])
+                worker[kTaskInfo].done(error(err));
+            else
+                this.emit("error", err);
+            // Remove the worker from the list and start a new Worker to replace the
+            // current one.
+            this.workers.splice(this.workers.indexOf(worker), 1);
+            this.addNewWorker();
+        });
+        this.workers.push(worker);
+        this.freeWorkers.push(worker);
+        this.emit(kWorkerFreedEvent);
+    }
+    runTask(task, callback) {
+        if (this.freeWorkers.length === 0) {
+            // No free threads, wait until a worker thread becomes free.
+            this.tasks.push({ task, callback });
+            return;
+        }
+        const worker = this.freeWorkers.pop();
+        if (worker) {
+            worker[kTaskInfo] = new WorkerPoolTaskInfo(callback);
+            worker.postMessage(task);
+        }
+    }
+    close() {
+        return Promise.all(this.workers.map(worker => worker.terminate()));
+    }
+}

package/dist/src/shared/api.d.ts

@@ -1,5 +1,8 @@
-import type { SerializedDecl } from "../node/schema/declarations/Declaration.ts";
+import type { CreatedEntityTaggedInstanceContainerWithChildInstances, EntityTaggedInstanceContainerWithChildInstances, UpdatedEntityTaggedInstanceContainerWithChildInstances } from "../node/utils/childInstances.ts";
+import type { WebConfig } from "../web/context/config.ts";
+import type { SerializedDecl } from "./schema/declarations/Declaration.ts";
 import type { InstanceContainer, InstanceContainerOverview } from "./utils/instances.ts";
+export type GetWebConfigResponseBody = WebConfig;
 export interface GetAllDeclarationsResponseBody<D extends SerializedDecl = SerializedDecl> {
     declarations: {
         declaration: D;
@@ -16,6 +19,12 @@ export interface GetAllInstancesOfEntityResponseBody {
     instances: InstanceContainerOverview[];
     isLocaleEntity: boolean;
 }
+export interface GetAllChildInstancesOfInstanceResponseBody {
+    instances: EntityTaggedInstanceContainerWithChildInstances[];
+}
+export interface CreateInstanceOfEntityRequestBody {
+    instance: CreatedEntityTaggedInstanceContainerWithChildInstances;
+}
 export interface CreateInstanceOfEntityResponseBody {
     instance: InstanceContainer;
     isLocaleEntity: boolean;
@@ -24,6 +33,9 @@ export interface GetInstanceOfEntityResponseBody {
     instance: InstanceContainer;
     isLocaleEntity: boolean;
 }
+export interface UpdateInstanceOfEntityRequestBody {
+    instance: UpdatedEntityTaggedInstanceContainerWithChildInstances;
+}
 export interface UpdateInstanceOfEntityResponseBody {
     instance: InstanceContainer;
     isLocaleEntity: boolean;
@@ -37,6 +49,7 @@ export interface GetAllInstancesResponseBody {
         [entity: string]: {
             id: string;
             name: string;
+            displayNameLocaleId?: string;
         }[];
     };
 }

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

@@ -0,0 +1,63 @@
+import type { SerializedDecl } from "./declarations/Declaration.ts";
+import { type SerializedEntityDecl } from "./declarations/EntityDecl.ts";
+import { type SerializedEnumDecl } from "./declarations/EnumDecl.ts";
+import { type SerializedTypeAliasDecl } from "./declarations/TypeAliasDecl.ts";
+import { type SerializedTypeParameter } from "./TypeParameter.ts";
+import { type SerializedArrayType } from "./types/ArrayType.ts";
+import { type SerializedBooleanType } from "./types/BooleanType.ts";
+import { type SerializedChildEntitiesType } from "./types/ChildEntitiesType.ts";
+import { type SerializedDateType } from "./types/DateType.ts";
+import { type SerializedEnumCaseDecl, type SerializedEnumType } from "./types/EnumType.ts";
+import { type SerializedFloatType } from "./types/FloatType.ts";
+import { type SerializedIncludeIdentifierType } from "./types/IncludeIdentifierType.ts";
+import { type SerializedIntegerType } from "./types/IntegerType.ts";
+import { type SerializedNestedEntityMapType } from "./types/NestedEntityMapType.ts";
+import { type SerializedMemberDecl, type SerializedObjectType } from "./types/ObjectType.ts";
+import { type SerializedReferenceIdentifierType } from "./types/ReferenceIdentifierType.ts";
+import { type SerializedStringType } from "./types/StringType.ts";
+import type { SerializedType } from "./types/Type.ts";
+import { type SerializedTypeArgumentType } from "./types/TypeArgumentType.ts";
+export interface NodeKind {
+    ChildEntityDecl: "ChildEntityDecl";
+    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";
+    TypeParameter: "TypeParameter";
+    ReferenceIdentifierType: "ReferenceIdentifierType";
+    IncludeIdentifierType: "IncludeIdentifierType";
+    NestedEntityMapType: "NestedEntityMapType";
+    EnumType: "EnumType";
+    ChildEntitiesType: "ChildEntitiesType";
+}
+export declare const NodeKind: NodeKind;
+export interface BaseNode {
+    kind: (typeof NodeKind)[keyof typeof NodeKind];
+}
+export type SerializedNode = SerializedDecl | SerializedType | SerializedTypeParameter;
+export type SerializedNodeWithResolvedTypeArguments<T extends SerializedNode | null> = T extends SerializedBooleanType | SerializedDateType | SerializedFloatType | SerializedIntegerType | SerializedStringType | SerializedReferenceIdentifierType ? T : T extends SerializedEntityDecl<infer N, infer P, infer FK> ? SerializedEntityDecl<N, {
+    [K in keyof P]: P[K] extends SerializedMemberDecl<infer PT, infer R> ? SerializedMemberDecl<SerializedNodeWithResolvedTypeArguments<PT>, R> : never;
+}, FK> : T extends SerializedEnumDecl<infer N, infer V, SerializedTypeParameter[]> ? SerializedEnumDecl<N, {
+    [K in keyof V]: V[K] extends SerializedEnumCaseDecl<infer CT> ? SerializedEnumCaseDecl<SerializedNodeWithResolvedTypeArguments<CT>> : never;
+}, [
+]> : T extends SerializedTypeAliasDecl<infer N, infer U, SerializedTypeParameter[]> ? SerializedTypeAliasDecl<N, SerializedNodeWithResolvedTypeArguments<U>, []> : T extends SerializedArrayType<infer I> ? SerializedArrayType<SerializedNodeWithResolvedTypeArguments<I>> : T extends SerializedEnumType<infer V> ? SerializedEnumType<{
+    [K in keyof V]: V[K] extends SerializedEnumCaseDecl<infer CT> ? SerializedEnumCaseDecl<SerializedNodeWithResolvedTypeArguments<CT>> : never;
+}> : T extends SerializedObjectType<infer P> ? SerializedObjectType<{
+    [K in keyof P]: P[K] extends SerializedMemberDecl<infer PT, infer R> ? SerializedMemberDecl<SerializedNodeWithResolvedTypeArguments<PT>, R> : never;
+}> : T extends SerializedTypeArgumentType ? SerializedType : T extends SerializedIncludeIdentifierType<[]> ? T : T extends SerializedIncludeIdentifierType ? SerializedType : T extends SerializedNestedEntityMapType<infer N, infer P> ? SerializedNestedEntityMapType<N, {
+    [K in keyof P]: P[K] extends SerializedMemberDecl<infer PT, infer R> ? SerializedMemberDecl<SerializedNodeWithResolvedTypeArguments<PT>, R> : never;
+}> : T extends SerializedTypeParameter<infer N, infer C> ? SerializedTypeParameter<N, SerializedNodeWithResolvedTypeArguments<C>> : T extends SerializedChildEntitiesType ? SerializedChildEntitiesType : T extends null ? null : never;
+export type SerializedTypeArgumentsResolver<T extends SerializedNode = SerializedNode> = (decls: Record<string, SerializedDecl>, args: Record<string, SerializedType>, node: T) => SerializedNodeWithResolvedTypeArguments<T>;
+export declare const resolveSerializedTypeArguments: <T extends SerializedNode = SerializedNode>(decls: Record<string, SerializedDecl>, args: Record<string, SerializedType>, node: T) => SerializedNodeWithResolvedTypeArguments<T>;
+export type GetReferencesSerialized<T extends SerializedNode = SerializedNode> = (decls: Record<string, SerializedDecl>, node: T, value: unknown) => string[];
+export declare const getReferencesSerialized: GetReferencesSerialized;
+export declare const getDecl: (decls: Record<string, SerializedDecl>, name: string) => SerializedDecl;