tsondb 0.21.11 → 0.23.0

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

@@ -0,0 +1,158 @@
+import type { InstanceContainer, InstanceContainerOverview, SingletonInstanceContainer } from "../shared/utils/instances.ts";
+import type { FormatterOptions } from "./config.ts";
+import { type ChildEntity, type ChildEntityConfig, type ChildEntityName, type DefaultTSONDBTypes, type Entity, type EntityName, type SingletonEntityName, type TSONDBOptions, type ValidationOptions } from "./index.ts";
+import type { Output } from "./output.ts";
+import type { EntityDecl } from "./schema/dsl/index.ts";
+import type { IdArgsVariant } from "./schema/generatedTypeHelpers.ts";
+import type { Schema } from "./schema/index.ts";
+import { DatabaseInMemory } from "./utils/databaseInMemory.ts";
+import { type ReferencesToInstances } from "./utils/references.ts";
+/**
+ * The main class for managing a typed JSON database that is read-only.
+ */
+export declare class ReadonlyTSONDB<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> {
+    #private;
+    protected _data: DatabaseInMemory<T["entityMap"], T["singletonEntityMap"]>;
+    protected _referencesToInstances: ReferencesToInstances;
+    protected _validationOptions: ValidationOptions;
+    protected _formatterOptions: Partial<FormatterOptions> | undefined;
+    protected constructor(options: {
+        dataRootPath: string;
+        data: DatabaseInMemory<T["entityMap"], T["singletonEntityMap"]>;
+        schema: Schema<T>;
+        locales?: string[];
+        referencesToInstances: ReferencesToInstances;
+        validationOptions: ValidationOptions;
+        formatterOptions?: Partial<FormatterOptions> | undefined;
+    });
+    /**
+     * Creates a new TSONDB instance with the specified options.
+     *
+     * @param options The options for creating the TSONDB instance.
+     * @param skipReferenceCache If set to `true`, the reference cache will not be created during initialization. This can speed up the initialization process, but referential integrity checks will not work correctly until the cache is created. This should only be set to `true` if you plan to call `sync()` immediately after initialization.
+     */
+    static create<Types extends DefaultTSONDBTypes = DefaultTSONDBTypes>(options: TSONDBOptions<Types>, skipReferenceCache?: boolean): Promise<ReadonlyTSONDB<Types>>;
+    /**
+     * Generates outputs based on the provided schema and output configurations.
+     */
+    static generateOutputs(options: {
+        schema: Schema;
+        outputs: Output[];
+    }): Promise<void>;
+    /**
+     * Generates outputs based on the current schema and the provided output configurations.
+     */
+    generateOutputs(outputs: Output[]): Promise<void>;
+    /**
+     * Validates the data in the database.
+     *
+     * Returns `true` if the data is valid, `false` otherwise.
+     */
+    validate(): boolean;
+    /**
+     * Checks if the data on disk is formatted according to the current in-memory representation.
+     */
+    checkFormat(): Promise<boolean>;
+    /**
+     * Reloads the data from disk into memory.
+     */
+    sync(): Promise<void>;
+    /**
+     * Retrieves an instance of the specified entity by its identifier.
+     */
+    getInstanceOfEntityById<E extends EntityName<T>>(...args: IdArgsVariant<T["entityMap"], E>): T["entityMap"][E] | undefined;
+    /**
+     * Retrieves the instance container of the specified entity by its identifier.
+     */
+    getInstanceContainerOfEntityById<E extends EntityName<T>>(...args: IdArgsVariant<T["entityMap"], E>): InstanceContainer<T["entityMap"][E]> | undefined;
+    /**
+     * Retrieves the overview of an instance of the specified entity by its identifier.
+     */
+    getInstanceOverviewOfEntityById(...args: IdArgsVariant<T["entityMap"]>): InstanceContainerOverview | undefined;
+    /**
+     * Retrieves all instances of the specified entity.
+     */
+    getAllInstancesOfEntity<E extends EntityName<T>>(entityName: E): Entity<T, E>[];
+    /**
+     * Retrieves all instance containers of the specified entity.
+     */
+    getAllInstanceContainersOfEntity<E extends EntityName<T>>(entityName: E): InstanceContainer<Entity<T, E>>[];
+    /**
+     * Retrieves all instance overviews of the specified entity.
+     */
+    getAllInstanceOverviewsOfEntity(entity: EntityDecl<EntityName<T>> | EntityName<T>): InstanceContainerOverview[];
+    /**
+     * Retrieves an instance of the specified entity by its identifier.
+     */
+    getSingletonInstanceOfEntity<E extends SingletonEntityName<T>>(entityName: E): T["singletonEntityMap"][E] | undefined;
+    /**
+     * Retrieves the instance container of the specified entity by its identifier.
+     */
+    getSingletonInstanceContainerOfEntity<E extends SingletonEntityName<T>>(entityName: E): SingletonInstanceContainer<T["singletonEntityMap"][E]> | undefined;
+    /**
+     * Counts the number of instances registered for the specified entity.
+     */
+    countInstancesOfEntity(entityName: EntityName<T>): number;
+    /**
+     * Returns whether the singleton entity has an instance.
+     */
+    hasInstanceOfSingletonEntity(entityName: SingletonEntityName<T>): boolean;
+    /**
+     * Retrieves overviews for all instances in the database, grouped by entity name.
+     */
+    getAllInstanceOverviews(): Record<EntityName<T>, InstanceContainerOverview[]>;
+    /**
+     * Retrieves all instance containers of the specified child entity for a given parent instance.
+     */
+    getAllChildInstanceContainersForParent<U extends ChildEntityName<T>>(childEntityName: U, parentId: ChildEntityConfig<T, U>[2]): InstanceContainer<ChildEntity<T, U>>[];
+    /**
+     * Displays the name of an entity instance including its ID. If no display name is found, `undefined` is returned.
+     */
+    getDisplayName(...args: IdArgsVariant<T["entityMap"]>): string | undefined;
+    /**
+     * Displays the name of an entity instance including its ID. If no display name is found, only the ID is returned.
+     */
+    getDisplayNameWithId(...args: IdArgsVariant<T["entityMap"]>): string;
+    /**
+     * Checks if a given instance is referenced by other instances in the database.
+     *
+     * If `otherInstancesToDelete` is provided, those instances will be excluded from the check. This can be useful when planning to delete multiple instances at once and wanting to ignore references from those instances.
+     */
+    isReferencedByOtherInstances(instance: string, otherInstancesToDelete?: string[]): boolean;
+    /**
+     * The configured locales for this TSONDB instance.
+     */
+    get locales(): string[];
+    /**
+     * Sets the locales for this TSONDB instance.
+     *
+     * The provided locales must exist in the database if a locale entity is defined in the schema.
+     */
+    setLocales(locales: string[]): void;
+    /**
+     * The loaded schema for this TSONDB instance.
+     */
+    get schema(): Schema<T>;
+    get dataRootPath(): string;
+    /**
+     * Searches for instances matching the provided query in their ID or display name.
+     *
+     * The results are sorted by relevance. A custom relevance score function can be provided.
+     */
+    search(query: string, options?: Partial<{
+        getRelevanceScore: <E extends EntityName<T>>(args: {
+            entityName: E;
+            id: string;
+            content: Entity<T, E>;
+            displayName: string;
+            displayNameLocaleId: string | undefined;
+            query: string;
+            queryLowerCase: string;
+        }) => number;
+    }>): [string, InstanceContainerOverview][];
+    /**
+     * Retrieves the name of the entity for a given instance ID. If no instance with the provided ID is found, `undefined` is returned.
+     */
+    getEntityNameOfInstanceId(id: string): string | undefined;
+}
+export type { Config } from "./config.ts";

package/dist/src/node/readonly.js

@@ -0,0 +1,321 @@
+import { on } from "@elyukai/utils/function";
+import { compareNumber, reduceCompare } from "@elyukai/utils/ordering";
+import Debug from "debug";
+import { stderr } from "node:process";
+import { styleText } from "node:util";
+import { TSONDB, } from "./index.js";
+import { getDisplayName, getDisplayNameWithId } from "./schema/detached.js";
+import { isEntityDeclWithParentReference } from "./schema/guards.js";
+import { checkLocales, generateOutputs, initData, prepareFolders, validate } from "./shared.js";
+import { DatabaseInMemory } from "./utils/databaseInMemory.js";
+import { getAllInstanceOverviewsByEntityName, getDisplayNameFromEntityInstance, getInstanceOverview, getInstanceOverviewsByEntityName, } from "./utils/displayName.js";
+import { formatInstance, readInstance, readSingletonInstance } from "./utils/files.js";
+import { isReferencedByOtherInstances } from "./utils/references.js";
+const debug = Debug("tsondb:readonly");
+/**
+ * The main class for managing a typed JSON database that is read-only.
+ */
+export class ReadonlyTSONDB {
+    _data;
+    #dataRootPath;
+    #schema;
+    #locales;
+    _referencesToInstances;
+    _validationOptions;
+    _formatterOptions;
+    constructor(options) {
+        this.#dataRootPath = options.dataRootPath;
+        this._data = options.data;
+        this.#schema = options.schema;
+        this.#locales = options.locales ?? [];
+        this._referencesToInstances = options.referencesToInstances;
+        this._validationOptions = options.validationOptions;
+        this._formatterOptions = options.formatterOptions;
+    }
+    /**
+     * Creates a new TSONDB instance with the specified options.
+     *
+     * @param options The options for creating the TSONDB instance.
+     * @param skipReferenceCache If set to `true`, the reference cache will not be created during initialization. This can speed up the initialization process, but referential integrity checks will not work correctly until the cache is created. This should only be set to `true` if you plan to call `sync()` immediately after initialization.
+     */
+    static async create(options, skipReferenceCache = false) {
+        const { entities } = options.schema;
+        debug("using data root path: %s", options.dataRootPath);
+        await prepareFolders(options.schema.version, options.dataRootPath, entities);
+        debug("prepared folders");
+        const { localeEntity } = options.schema;
+        if (!localeEntity && options.locales) {
+            throw new Error("Schema does not contain a locale entity, locales cannot be provided.");
+        }
+        const { data, referencesToInstances } = await initData(options.dataRootPath, options.schema, options.locales ?? [], undefined, undefined, skipReferenceCache, true);
+        const db = new ReadonlyTSONDB({
+            ...options,
+            data,
+            referencesToInstances,
+            validationOptions: {
+                checkReferentialIntegrity: true,
+                checkOnlyEntities: [],
+                ...options.validationOptions,
+            },
+        });
+        return db;
+    }
+    /**
+     * Generates outputs based on the provided schema and output configurations.
+     */
+    static async generateOutputs(options) {
+        await generateOutputs(options.schema, options.outputs);
+    }
+    /**
+     * Generates outputs based on the current schema and the provided output configurations.
+     */
+    async generateOutputs(outputs) {
+        await generateOutputs(this.#schema, outputs);
+    }
+    #validate(data, options = {}) {
+        return validate({
+            data,
+            dataRootPath: this.#dataRootPath,
+            locales: this.#locales,
+            schema: this.#schema,
+            validationOptions: this._validationOptions,
+        }, options);
+    }
+    /**
+     * Validates the data in the database.
+     *
+     * Returns `true` if the data is valid, `false` otherwise.
+     */
+    validate() {
+        debug("Validating database ...");
+        return this.#validate(this._data).length === 0;
+    }
+    /**
+     * Checks if the data on disk is formatted according to the current in-memory representation.
+     */
+    async checkFormat() {
+        debug("Check database formatting ...");
+        let counter = 0;
+        let total = 0;
+        await this._data.forEachInstance(async (entityName, instance) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const entity = this.#schema.getEntity(entityName);
+            const instanceOnDisk = await readInstance(this.#dataRootPath, entity, instance.id);
+            const currentFormatted = formatInstance(entity, instance.content, this._formatterOptions);
+            if (instanceOnDisk !== currentFormatted) {
+                console.log(`Instance ${styleText("yellow", instance.id)} of entity ${styleText("cyan", entityName)} is not formatted correctly.`);
+                counter++;
+            }
+            total++;
+        }, true);
+        await this._data.forEachSingletonInstance(async (entityName, instance) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const entity = this.#schema.getSingletonEntity(entityName);
+            const instanceOnDisk = await readSingletonInstance(this.#dataRootPath, entity);
+            const currentFormatted = formatInstance(entity, instance.content, this._formatterOptions);
+            if (instanceOnDisk !== currentFormatted) {
+                console.log(`Singleton instance of entity ${styleText("cyan", entityName)} is not formatted correctly.`);
+                counter++;
+            }
+            total++;
+        }, true);
+        if (counter === 0) {
+            console.log(styleText("green", `All ${total.toFixed()} instance${total === 1 ? "" : "s"} are formatted correctly`));
+            return true;
+        }
+        else {
+            console.error(styleText("red", `${counter.toFixed()} instance${counter === 1 ? "" : "s"} of ${total.toFixed()} instance${total === 1 ? "" : "s"} are not formatted correctly`, {
+                stream: stderr,
+            }));
+            return false;
+        }
+    }
+    /**
+     * Reloads the data from disk into memory.
+     */
+    async sync() {
+        debug("Syncing with disk ...");
+        const { data, referencesToInstances } = await initData(this.#dataRootPath, this.#schema, this.#locales, undefined, undefined, false, !(this instanceof TSONDB));
+        this._data = data;
+        this._referencesToInstances = referencesToInstances;
+        debug("Synced with disk");
+    }
+    /**
+     * Retrieves an instance of the specified entity by its identifier.
+     */
+    getInstanceOfEntityById(...args) {
+        return this._data.getInstanceContainerOfEntityById(...args)?.content;
+    }
+    /**
+     * Retrieves the instance container of the specified entity by its identifier.
+     */
+    getInstanceContainerOfEntityById(...args) {
+        return this._data.getInstanceContainerOfEntityById(...args);
+    }
+    /**
+     * Retrieves the overview of an instance of the specified entity by its identifier.
+     */
+    getInstanceOverviewOfEntityById(...args) {
+        return getInstanceOverview(this.getInstanceContainerOfEntityById.bind(this), this.getAllChildInstanceContainersForParent.bind(this), this.#schema.getEntity.bind(this.#schema), this.#locales, args);
+    }
+    /**
+     * Retrieves all instances of the specified entity.
+     */
+    getAllInstancesOfEntity(entityName) {
+        return this._data.getAllInstanceContainersOfEntity(entityName).map(ic => ic.content);
+    }
+    /**
+     * Retrieves all instance containers of the specified entity.
+     */
+    getAllInstanceContainersOfEntity(entityName) {
+        return this._data.getAllInstanceContainersOfEntity(entityName);
+    }
+    /**
+     * Retrieves all instance overviews of the specified entity.
+     */
+    getAllInstanceOverviewsOfEntity(entity) {
+        const normEntity = typeof entity === "object" ? entity : this.#schema.getEntity(entity);
+        if (!normEntity) {
+            return [];
+        }
+        return getInstanceOverviewsByEntityName(this.getInstanceContainerOfEntityById.bind(this), this.getAllChildInstanceContainersForParent.bind(this), this.#schema.getEntity.bind(this.#schema), normEntity, this.getAllInstanceContainersOfEntity(normEntity.name), this.#locales);
+    }
+    /**
+     * Retrieves an instance of the specified entity by its identifier.
+     */
+    getSingletonInstanceOfEntity(entityName) {
+        return this._data.getSingletonInstanceOfEntity(entityName);
+    }
+    /**
+     * Retrieves the instance container of the specified entity by its identifier.
+     */
+    getSingletonInstanceContainerOfEntity(entityName) {
+        return this._data.getSingletonInstanceContainerOfEntity(entityName);
+    }
+    /**
+     * Counts the number of instances registered for the specified entity.
+     */
+    countInstancesOfEntity(entityName) {
+        return this._data.countInstancesOfEntity(entityName);
+    }
+    /**
+     * Returns whether the singleton entity has an instance.
+     */
+    hasInstanceOfSingletonEntity(entityName) {
+        return this._data.hasInstanceOfSingletonEntity(entityName);
+    }
+    /**
+     * Retrieves overviews for all instances in the database, grouped by entity name.
+     */
+    getAllInstanceOverviews() {
+        return getAllInstanceOverviewsByEntityName(this.#schema.getEntity.bind(this.#schema), this._data, this.#locales);
+    }
+    /**
+     * Retrieves all instance containers of the specified child entity for a given parent instance.
+     */
+    getAllChildInstanceContainersForParent(childEntityName, parentId) {
+        return this._data.getAllChildInstanceContainersForParent(this.#schema.getEntity.bind(this.#schema), childEntityName, parentId);
+    }
+    /**
+     * Displays the name of an entity instance including its ID. If no display name is found, `undefined` is returned.
+     */
+    getDisplayName(...args) {
+        return getDisplayName(this.#schema.getEntity.bind(this.#schema), this.#locales, this._data, ...args);
+    }
+    /**
+     * Displays the name of an entity instance including its ID. If no display name is found, only the ID is returned.
+     */
+    getDisplayNameWithId(...args) {
+        return getDisplayNameWithId(this.#schema.getEntity.bind(this.#schema), this.#locales, this._data, ...args);
+    }
+    /**
+     * Checks if a given instance is referenced by other instances in the database.
+     *
+     * If `otherInstancesToDelete` is provided, those instances will be excluded from the check. This can be useful when planning to delete multiple instances at once and wanting to ignore references from those instances.
+     */
+    isReferencedByOtherInstances(instance, otherInstancesToDelete) {
+        return isReferencedByOtherInstances(this._referencesToInstances, instance, otherInstancesToDelete);
+    }
+    /**
+     * The configured locales for this TSONDB instance.
+     */
+    get locales() {
+        return this.#locales;
+    }
+    /**
+     * Sets the locales for this TSONDB instance.
+     *
+     * The provided locales must exist in the database if a locale entity is defined in the schema.
+     */
+    setLocales(locales) {
+        checkLocales(this.#schema, this._data, locales);
+        this.#locales = locales;
+    }
+    /**
+     * The loaded schema for this TSONDB instance.
+     */
+    get schema() {
+        return this.#schema;
+    }
+    get dataRootPath() {
+        return this.#dataRootPath;
+    }
+    /**
+     * Searches for instances matching the provided query in their ID or display name.
+     *
+     * The results are sorted by relevance. A custom relevance score function can be provided.
+     */
+    search(query, options = {}) {
+        if (!query || query.trim().length === 0) {
+            return [];
+        }
+        const { getRelevanceScore = ({ id, displayName }) => {
+            const searchableName = displayName.toLowerCase();
+            return id.startsWith(query) || searchableName.startsWith(lowerCaseQuery)
+                ? 1
+                : id.includes(query) || searchableName.includes(lowerCaseQuery)
+                    ? 0.5
+                    : 0;
+        }, } = options;
+        const lowerCaseQuery = query.toLowerCase();
+        return this._data
+            .getAllInstances()
+            .flatMap(([entityName, instances]) => {
+            const entity = this.#schema.getEntity(entityName);
+            if (entity && isEntityDeclWithParentReference(entity)) {
+                return [];
+            }
+            return instances
+                .map((instance) => {
+                const { name, localeId } = getDisplayNameFromEntityInstance(
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                entity, instance, this.#schema.getEntity.bind(this.#schema), this.getInstanceContainerOfEntityById.bind(this), this.getAllChildInstanceContainersForParent.bind(this), this.#locales);
+                return [
+                    entityName,
+                    {
+                        id: instance.id,
+                        displayName: name,
+                        displayNameLocaleId: localeId,
+                        relevance: getRelevanceScore({
+                            entityName,
+                            id: instance.id,
+                            content: instance.content,
+                            displayName: name,
+                            displayNameLocaleId: localeId,
+                            query,
+                            queryLowerCase: lowerCaseQuery,
+                        }),
+                    },
+                ];
+            })
+                .filter(instance => instance[1].relevance > 0);
+        })
+            .toSorted(reduceCompare(on(item => item[1].relevance, compareNumber), (a, b) => a[1].displayName.localeCompare(b[1].displayName, a[1].displayNameLocaleId)));
+    }
+    /**
+     * Retrieves the name of the entity for a given instance ID. If no instance with the provided ID is found, `undefined` is returned.
+     */
+    getEntityNameOfInstanceId(id) {
+        return this._data.getEntityNameOfInstanceId(id);
+    }
+}

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

@@ -1,8 +1,6 @@
-import type { HomeLayoutSection, ServerConfig } from "../config.ts";
+import type { HomeLayoutSection, ServerOptions } from "../config.ts";
 import type { DefaultTSONDBTypes, TSONDB, ValidationOptions } from "../index.ts";
-export type ServerOptions = {
-    port: number;
-};
+export type { ServerOptions };
 export interface TSONDBRequestLocals {
     db: TSONDB;
     defaultLocales: string[];
@@ -16,4 +14,7 @@ declare global {
         }
     }
 }
-export declare const createServer: <T extends DefaultTSONDBTypes = DefaultTSONDBTypes>(db: TSONDB<T>, config: Omit<ServerConfig<T>, "locales">) => void;
+export declare const createServer: <T extends DefaultTSONDBTypes = DefaultTSONDBTypes>(db: TSONDB<T>, config: {
+    serverOptions?: ServerOptions;
+    validationOptions?: Partial<ValidationOptions>;
+}, callback?: (error?: NodeJS.ErrnoException) => void) => void;

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

@@ -15,9 +15,12 @@ const staticNodeModule = (moduleName) => {
     }
     return express.static(dirname(pathToPackageJson));
 };
-export const createServer = (db, config) => {
-    const { serverOptions: options, homeLayoutSections, validationOptions, customAssetsPath, customStylesheetPath, } = config;
-    const { port } = { ...defaultOptions, ...options };
+export const createServer = (db, config, callback) => {
+    const { serverOptions: options, validationOptions } = config;
+    const { port, homeLayoutSections, customAssetsPath, customStylesheetPath } = {
+        ...defaultOptions,
+        ...options,
+    };
     const app = express();
     app.use(express.static(join(import.meta.dirname, "../../../../public")));
     app.use("/js/node_modules/preact", staticNodeModule("preact"));
@@ -84,5 +87,6 @@ export const createServer = (db, config) => {
         else {
             debug(`server listening on http://localhost:${port.toString()}`);
         }
+        callback?.(error);
     });
 };

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

@@ -0,0 +1,46 @@
+import type { SimpleGit, StatusResult } from "simple-git";
+import type { InstanceContent } from "../shared/utils/instances.ts";
+import type { DefaultTSONDBTypes, ValidationOptions } from "./index.ts";
+import type { Output } from "./output.ts";
+import type { EntityDecl } from "./schema/dsl/index.ts";
+import type { AnyEntityMap, AnySingletonEntityMap, RegisteredEntityMap, RegisteredSingletonEntityMap } from "./schema/generatedTypeHelpers.ts";
+import type { Schema } from "./schema/index.ts";
+import { DatabaseInMemory } from "./utils/databaseInMemory.ts";
+import { type ReferencesToInstances } from "./utils/references.ts";
+interface MetaFile {
+    version: string;
+    schemaVersion: string;
+}
+export declare const getTSONDBVersion: () => Promise<string>;
+export declare const readMetaFile: (dataRootPath: string) => Promise<MetaFile>;
+export declare const writeMetaFile: (dataRootPath: string, meta: MetaFile) => Promise<void>;
+export declare const prepareFolders: (schemaVersion: string, dataRootPath: string, entities: EntityDecl[]) => Promise<void>;
+export declare const generateOutputs: <T extends DefaultTSONDBTypes>(schema: Schema<T>, outputs: Output[]) => Promise<void>;
+export declare const checkLocales: <T extends DefaultTSONDBTypes>(schema: Schema<T>, data: DatabaseInMemory<T["entityMap"]>, locales: string[]) => void;
+export type TSONDBGit = {
+    client: SimpleGit;
+    root: string;
+};
+export declare const initData: <T extends DefaultTSONDBTypes>(dataRootPath: string, schema: Schema<T>, locales: string[], git: TSONDBGit | undefined, gitStatus: StatusResult | undefined, skipReferenceCache: boolean, allowCompressedFile: boolean) => Promise<{
+    data: DatabaseInMemory<T["entityMap"], T["singletonEntityMap"]>;
+    referencesToInstances: ReferencesToInstances;
+    meta: MetaFile;
+}>;
+export declare const validate: <T extends DefaultTSONDBTypes>(properties: {
+    data: DatabaseInMemory<T["entityMap"], T["singletonEntityMap"]>;
+    schema: Schema<T>;
+    validationOptions: ValidationOptions;
+    dataRootPath: string;
+    locales: string[];
+}, options?: {
+    logToConsole?: boolean;
+    skipStructuralValidation?: boolean;
+    changedEntities?: Extract<keyof (T["entityMap"] & T["singletonEntityMap"]), string>[];
+}) => Error[];
+export type CompressedDatabaseFile<EM extends AnyEntityMap = RegisteredEntityMap, SEM extends AnySingletonEntityMap = RegisteredSingletonEntityMap> = {
+    meta: MetaFile;
+    data: Record<keyof EM, Record<string, InstanceContent>> & Record<keyof SEM, InstanceContent>;
+};
+export declare const createCompressedDatabaseFile: <EM extends AnyEntityMap = RegisteredEntityMap, SEM extends AnySingletonEntityMap = RegisteredSingletonEntityMap>(data: DatabaseInMemory<EM, SEM>, schemaVersion: string) => CompressedDatabaseFile<EM, SEM>;
+export declare const isEntityPair: <EM extends AnyEntityMap = RegisteredEntityMap, SEM extends AnySingletonEntityMap = RegisteredSingletonEntityMap>(pair: [Extract<keyof EM, string>, Record<string, InstanceContent>] | [Extract<keyof SEM, string>, InstanceContent], isEntityName: (entityName: Extract<keyof EM | keyof SEM, string>) => entityName is Extract<keyof EM, string>) => pair is [Extract<keyof EM, string>, Record<string, InstanceContent>];
+export {};