tsondb 0.5.18 → 0.6.0

package/dist/src/shared/schema/Node.js

@@ -0,0 +1,128 @@
+import { enumOfObject } from "../utils/enum.js";
+import { assertExhaustive } from "../utils/typeSafety.js";
+import { getReferencesForSerializedEntityDecl, resolveTypeArgumentsInSerializedEntityDecl, } from "./declarations/EntityDecl.js";
+import { getReferencesForSerializedEnumDecl, resolveTypeArgumentsInSerializedEnumDecl, } from "./declarations/EnumDecl.js";
+import { getReferencesForSerializedTypeAliasDecl, resolveTypeArgumentsInSerializedTypeAliasDecl, } from "./declarations/TypeAliasDecl.js";
+import { getReferencesForSerializedTypeParameter, resolveTypeArgumentsInSerializedTypeParameter, } from "./TypeParameter.js";
+import { getReferencesForSerializedArrayType, resolveTypeArgumentsInSerializedArrayType, } from "./types/ArrayType.js";
+import { getReferencesForSerializedBooleanType, resolveTypeArgumentsInSerializedBooleanType, } from "./types/BooleanType.js";
+import { getReferencesForSerializedChildEntitiesType, resolveTypeArgumentsInSerializedChildEntitiesType, } from "./types/ChildEntitiesType.js";
+import { getReferencesForSerializedDateType, resolveTypeArgumentsInSerializedDateType, } from "./types/DateType.js";
+import { getReferencesForSerializedEnumType, resolveTypeArgumentsInSerializedEnumType, } from "./types/EnumType.js";
+import { getReferencesForSerializedFloatType, resolveTypeArgumentsInSerializedFloatType, } from "./types/FloatType.js";
+import { getReferencesForSerializedIncludeIdentifierType, resolveTypeArgumentsInSerializedIncludeIdentifierType, } from "./types/IncludeIdentifierType.js";
+import { getReferencesForSerializedIntegerType, resolveTypeArgumentsInSerializedIntegerType, } from "./types/IntegerType.js";
+import { getReferencesForSerializedNestedEntityMapType, resolveTypeArgumentsInSerializedNestedEntityMapType, } from "./types/NestedEntityMapType.js";
+import { getReferencesForSerializedObjectType, resolveTypeArgumentsInSerializedObjectType, } from "./types/ObjectType.js";
+import { getReferencesForSerializedReferenceIdentifierType, resolveTypeArgumentsInSerializedReferenceIdentifierType, } from "./types/ReferenceIdentifierType.js";
+import { getReferencesForSerializedStringType, resolveTypeArgumentsInSerializedStringType, } from "./types/StringType.js";
+import { getReferencesForSerializedTypeArgumentType, resolveTypeArgumentsInSerializedTypeArgumentType, } from "./types/TypeArgumentType.js";
+export const NodeKind = enumOfObject({
+    ChildEntityDecl: null,
+    EntityDecl: null,
+    EnumDecl: null,
+    EnumCaseDecl: null,
+    TypeAliasDecl: null,
+    MemberDecl: null,
+    ArrayType: null,
+    ObjectType: null,
+    BooleanType: null,
+    FloatType: null,
+    IntegerType: null,
+    StringType: null,
+    DateType: null,
+    TypeArgumentType: null,
+    TypeParameter: null,
+    ReferenceIdentifierType: null,
+    IncludeIdentifierType: null,
+    NestedEntityMapType: null,
+    EnumType: null,
+    ChildEntitiesType: null,
+});
+export const resolveSerializedTypeArguments = (decls, args, node) => {
+    switch (node.kind) {
+        case NodeKind.EntityDecl:
+            return resolveTypeArgumentsInSerializedEntityDecl(decls, args, node);
+        case NodeKind.EnumDecl:
+            return resolveTypeArgumentsInSerializedEnumDecl(decls, args, node);
+        case NodeKind.TypeAliasDecl:
+            return resolveTypeArgumentsInSerializedTypeAliasDecl(decls, args, node);
+        case NodeKind.ArrayType:
+            return resolveTypeArgumentsInSerializedArrayType(decls, args, node);
+        case NodeKind.ObjectType:
+            return resolveTypeArgumentsInSerializedObjectType(decls, args, node);
+        case NodeKind.BooleanType:
+            return resolveTypeArgumentsInSerializedBooleanType(decls, args, node);
+        case NodeKind.DateType:
+            return resolveTypeArgumentsInSerializedDateType(decls, args, node);
+        case NodeKind.FloatType:
+            return resolveTypeArgumentsInSerializedFloatType(decls, args, node);
+        case NodeKind.IntegerType:
+            return resolveTypeArgumentsInSerializedIntegerType(decls, args, node);
+        case NodeKind.StringType:
+            return resolveTypeArgumentsInSerializedStringType(decls, args, node);
+        case NodeKind.TypeArgumentType:
+            return resolveTypeArgumentsInSerializedTypeArgumentType(decls, args, node);
+        case NodeKind.ReferenceIdentifierType:
+            return resolveTypeArgumentsInSerializedReferenceIdentifierType(decls, args, node);
+        case NodeKind.IncludeIdentifierType:
+            return resolveTypeArgumentsInSerializedIncludeIdentifierType(decls, args, node);
+        case NodeKind.NestedEntityMapType:
+            return resolveTypeArgumentsInSerializedNestedEntityMapType(decls, args, node);
+        case NodeKind.EnumType:
+            return resolveTypeArgumentsInSerializedEnumType(decls, args, node);
+        case NodeKind.TypeParameter:
+            return resolveTypeArgumentsInSerializedTypeParameter(decls, args, node);
+        case NodeKind.ChildEntitiesType:
+            return resolveTypeArgumentsInSerializedChildEntitiesType(decls, args, node);
+        default:
+            return assertExhaustive(node);
+    }
+};
+export const getReferencesSerialized = (decls, node, value) => {
+    switch (node.kind) {
+        case NodeKind.EntityDecl:
+            return getReferencesForSerializedEntityDecl(decls, node, value);
+        case NodeKind.EnumDecl:
+            return getReferencesForSerializedEnumDecl(decls, node, value);
+        case NodeKind.TypeAliasDecl:
+            return getReferencesForSerializedTypeAliasDecl(decls, node, value);
+        case NodeKind.ArrayType:
+            return getReferencesForSerializedArrayType(decls, node, value);
+        case NodeKind.ObjectType:
+            return getReferencesForSerializedObjectType(decls, node, value);
+        case NodeKind.BooleanType:
+            return getReferencesForSerializedBooleanType(decls, node, value);
+        case NodeKind.DateType:
+            return getReferencesForSerializedDateType(decls, node, value);
+        case NodeKind.FloatType:
+            return getReferencesForSerializedFloatType(decls, node, value);
+        case NodeKind.IntegerType:
+            return getReferencesForSerializedIntegerType(decls, node, value);
+        case NodeKind.StringType:
+            return getReferencesForSerializedStringType(decls, node, value);
+        case NodeKind.TypeArgumentType:
+            return getReferencesForSerializedTypeArgumentType(decls, node, value);
+        case NodeKind.ReferenceIdentifierType:
+            return getReferencesForSerializedReferenceIdentifierType(decls, node, value);
+        case NodeKind.IncludeIdentifierType:
+            return getReferencesForSerializedIncludeIdentifierType(decls, node, value);
+        case NodeKind.NestedEntityMapType:
+            return getReferencesForSerializedNestedEntityMapType(decls, node, value);
+        case NodeKind.EnumType:
+            return getReferencesForSerializedEnumType(decls, node, value);
+        case NodeKind.TypeParameter:
+            return getReferencesForSerializedTypeParameter(decls, node, value);
+        case NodeKind.ChildEntitiesType:
+            return getReferencesForSerializedChildEntitiesType(decls, node, value);
+        default:
+            return assertExhaustive(node);
+    }
+};
+export const getDecl = (decls, name) => {
+    const decl = decls[name];
+    if (!decl) {
+        throw new Error(`Declaration not found: ${name}`);
+    }
+    return decl;
+};

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

@@ -0,0 +1,9 @@
+import type { GetReferencesSerialized, NodeKind, SerializedTypeArgumentsResolver } from "./Node.ts";
+import type { SerializedBaseType, SerializedType } from "./types/Type.ts";
+export interface SerializedTypeParameter<N extends string = string, T extends SerializedType = SerializedType> extends SerializedBaseType {
+    kind: NodeKind["TypeParameter"];
+    name: N;
+    constraint?: T;
+}
+export declare const resolveTypeArgumentsInSerializedTypeParameter: SerializedTypeArgumentsResolver<SerializedTypeParameter>;
+export declare const getReferencesForSerializedTypeParameter: GetReferencesSerialized<SerializedTypeParameter>;

package/dist/src/shared/schema/TypeParameter.js

@@ -0,0 +1,2 @@
+export const resolveTypeArgumentsInSerializedTypeParameter = (_decls, _args, param) => param;
+export const getReferencesForSerializedTypeParameter = () => [];

package/dist/src/shared/schema/declarations/Declaration.d.ts

@@ -0,0 +1,21 @@
+import type { BaseNode } from "../Node.ts";
+import type { SerializedTypeParameter } from "../TypeParameter.ts";
+import type { SerializedEnumCaseDecl } from "../types/EnumType.ts";
+import type { SerializedMemberDecl } from "../types/ObjectType.ts";
+import { type SerializedType } from "../types/Type.ts";
+import type { SerializedEntityDecl } from "./EntityDecl.ts";
+import type { SerializedEnumDecl } from "./EnumDecl.ts";
+import type { SerializedTypeAliasDecl } from "./TypeAliasDecl.ts";
+export type SerializedTypeArguments<Params extends SerializedTypeParameter[]> = {
+    [K in keyof Params]: Params[K] extends SerializedTypeParameter<string, infer T> ? T : SerializedType;
+};
+export declare const getSerializedTypeArgumentsRecord: <Params extends SerializedTypeParameter[]>(decl: SerializedDeclP<Params>, args: SerializedTypeArguments<Params>) => Record<string, SerializedType>;
+export type SerializedDecl = SerializedEntityDecl | SerializedEnumDecl | SerializedTypeAliasDecl;
+export type SerializedDeclP<Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> = SerializedEntityDecl | SerializedEnumDecl<string, Record<string, SerializedEnumCaseDecl>, Params> | SerializedTypeAliasDecl<string, SerializedType, Params>;
+export type SerializedSecondaryDecl = SerializedEnumDecl | SerializedTypeAliasDecl | SerializedEntityDecl<string, Record<string, SerializedMemberDecl>, string>;
+export interface SerializedBaseDecl<Name extends string = string, Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> extends BaseNode {
+    sourceUrl: string;
+    name: Name;
+    comment?: string;
+    parameters: Params;
+}

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

@@ -0,0 +1,4 @@
+import {} from "../types/Type.js";
+export const getSerializedTypeArgumentsRecord = (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]));

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

@@ -0,0 +1,32 @@
+import type { Leaves } from "../../../shared/utils/object.ts";
+import { NodeKind, type GetReferencesSerialized, type SerializedNode, type SerializedTypeArgumentsResolver } from "../Node.ts";
+import { type SerializedMemberDecl, type SerializedObjectType } from "../types/ObjectType.ts";
+import type { SerializedAsType } from "../types/Type.ts";
+import type { SerializedBaseDecl } from "./Declaration.ts";
+export type SerializedEntityDisplayName<T extends SerializedObjectType> = Leaves<SerializedAsType<T>> | {
+    /**
+     * @default "translations"
+     */
+    pathToLocaleMap?: Leaves<SerializedAsType<T>>;
+    /**
+     * @default "name"
+     */
+    pathInLocaleMap?: string;
+} | null;
+type TConstraint = Record<string, SerializedMemberDecl>;
+export interface SerializedEntityDecl<Name extends string = string, T extends TConstraint = TConstraint, FK extends (keyof T & string) | undefined = (keyof T & string) | undefined> extends SerializedBaseDecl<Name, []> {
+    kind: NodeKind["EntityDecl"];
+    namePlural: string;
+    type: SerializedObjectType<T>;
+    parentReferenceKey: FK;
+    /**
+     * @default "name"
+     */
+    displayName?: SerializedEntityDisplayName<SerializedObjectType<T>>;
+    displayNameCustomizer: boolean;
+    isDeprecated?: boolean;
+}
+export declare const isSerializedEntityDecl: (node: SerializedNode) => node is SerializedEntityDecl;
+export declare const resolveTypeArgumentsInSerializedEntityDecl: SerializedTypeArgumentsResolver<SerializedEntityDecl>;
+export declare const getReferencesForSerializedEntityDecl: GetReferencesSerialized<SerializedEntityDecl>;
+export {};

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

@@ -0,0 +1,8 @@
+import { NodeKind, resolveSerializedTypeArguments, } from "../Node.js";
+import { getReferencesForSerializedObjectType, } from "../types/ObjectType.js";
+export const isSerializedEntityDecl = (node) => node.kind === NodeKind.EntityDecl;
+export const resolveTypeArgumentsInSerializedEntityDecl = (decls, _args, decl) => ({
+    ...decl,
+    type: resolveSerializedTypeArguments(decls, {}, decl.type),
+});
+export const getReferencesForSerializedEntityDecl = (decls, decl, value) => getReferencesForSerializedObjectType(decls, decl.type, value);

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

@@ -0,0 +1,11 @@
+import type { GetReferencesSerialized, NodeKind, SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedTypeParameter } from "../TypeParameter.ts";
+import { type SerializedEnumCaseDecl, type SerializedEnumType } from "../types/EnumType.ts";
+import type { SerializedBaseDecl } from "./Declaration.ts";
+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 resolveTypeArgumentsInSerializedEnumDecl: SerializedTypeArgumentsResolver<SerializedEnumDecl>;
+export declare const getReferencesForSerializedEnumDecl: GetReferencesSerialized<SerializedEnumDecl>;

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

@@ -0,0 +1,9 @@
+import { getReferencesForSerializedEnumType, resolveTypeArgumentsInSerializedEnumType, } from "../types/EnumType.js";
+export const resolveTypeArgumentsInSerializedEnumDecl = (decls, args, decl) => {
+    return {
+        ...decl,
+        parameters: [],
+        type: resolveTypeArgumentsInSerializedEnumType(decls, args, decl.type),
+    };
+};
+export const getReferencesForSerializedEnumDecl = (decls, decl, value) => getReferencesForSerializedEnumType(decls, decl.type, value);

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

@@ -0,0 +1,11 @@
+import { type GetReferencesSerialized, type NodeKind, type SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedTypeParameter } from "../TypeParameter.ts";
+import type { SerializedType } from "../types/Type.ts";
+import type { SerializedBaseDecl } from "./Declaration.ts";
+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 resolveTypeArgumentsInSerializedTypeAliasDecl: SerializedTypeArgumentsResolver<SerializedTypeAliasDecl>;
+export declare const getReferencesForSerializedTypeAliasDecl: GetReferencesSerialized<SerializedTypeAliasDecl>;

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

@@ -0,0 +1,7 @@
+import { getReferencesSerialized, resolveSerializedTypeArguments, } from "../Node.js";
+export const resolveTypeArgumentsInSerializedTypeAliasDecl = (decls, args, decl) => ({
+    ...decl,
+    parameters: [],
+    type: resolveSerializedTypeArguments(decls, args, decl.type),
+});
+export const getReferencesForSerializedTypeAliasDecl = (decls, decl, value) => getReferencesSerialized(decls, decl.type, value);

package/dist/src/shared/schema/types/ArrayType.d.ts

@@ -0,0 +1,11 @@
+import { type GetReferencesSerialized, type NodeKind, type SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedBaseType, SerializedType } from "./Type.ts";
+export interface SerializedArrayType<T extends SerializedType = SerializedType> extends SerializedBaseType {
+    kind: NodeKind["ArrayType"];
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    items: T;
+}
+export declare const resolveTypeArgumentsInSerializedArrayType: SerializedTypeArgumentsResolver<SerializedArrayType>;
+export declare const getReferencesForSerializedArrayType: GetReferencesSerialized<SerializedArrayType>;

package/dist/src/shared/schema/types/ArrayType.js

@@ -0,0 +1,8 @@
+import { getReferencesSerialized, resolveSerializedTypeArguments, } from "../Node.js";
+export const resolveTypeArgumentsInSerializedArrayType = (decls, args, type) => ({
+    ...type,
+    items: resolveSerializedTypeArguments(decls, args, type.items),
+});
+export const getReferencesForSerializedArrayType = (decls, type, value) => Array.isArray(value)
+    ? value.flatMap(item => getReferencesSerialized(decls, type.items, item))
+    : [];

package/dist/src/shared/schema/types/BooleanType.d.ts

@@ -0,0 +1,7 @@
+import type { GetReferencesSerialized, NodeKind, SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedBaseType } from "./Type.ts";
+export interface SerializedBooleanType extends SerializedBaseType {
+    kind: NodeKind["BooleanType"];
+}
+export declare const resolveTypeArgumentsInSerializedBooleanType: SerializedTypeArgumentsResolver<SerializedBooleanType>;
+export declare const getReferencesForSerializedBooleanType: GetReferencesSerialized<SerializedBooleanType>;

package/dist/src/shared/schema/types/BooleanType.js

@@ -0,0 +1,2 @@
+export const resolveTypeArgumentsInSerializedBooleanType = (_decls, _args, type) => type;
+export const getReferencesForSerializedBooleanType = () => [];

package/dist/src/shared/schema/types/ChildEntitiesType.d.ts

@@ -0,0 +1,8 @@
+import type { GetReferencesSerialized, NodeKind, SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedBaseType } from "./Type.ts";
+export interface SerializedChildEntitiesType extends SerializedBaseType {
+    kind: NodeKind["ChildEntitiesType"];
+    entity: string;
+}
+export declare const resolveTypeArgumentsInSerializedChildEntitiesType: SerializedTypeArgumentsResolver<SerializedChildEntitiesType>;
+export declare const getReferencesForSerializedChildEntitiesType: GetReferencesSerialized<SerializedChildEntitiesType>;

package/dist/src/shared/schema/types/ChildEntitiesType.js

@@ -0,0 +1,2 @@
+export const resolveTypeArgumentsInSerializedChildEntitiesType = (_decls, _args, type) => type;
+export const getReferencesForSerializedChildEntitiesType = () => [];

package/dist/src/shared/schema/types/DateType.d.ts

@@ -0,0 +1,8 @@
+import type { DateConstraints } from "../../validation/date.ts";
+import type { GetReferencesSerialized, NodeKind, SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedBaseType } from "./Type.ts";
+export interface SerializedDateType extends SerializedBaseType, DateConstraints {
+    kind: NodeKind["DateType"];
+}
+export declare const resolveTypeArgumentsInSerializedDateType: SerializedTypeArgumentsResolver<SerializedDateType>;
+export declare const getReferencesForSerializedDateType: GetReferencesSerialized<SerializedDateType>;

package/dist/src/shared/schema/types/DateType.js

@@ -0,0 +1,2 @@
+export const resolveTypeArgumentsInSerializedDateType = (_decls, _args, type) => type;
+export const getReferencesForSerializedDateType = () => [];

package/dist/src/shared/schema/types/EnumType.d.ts

@@ -0,0 +1,14 @@
+import { type GetReferencesSerialized, type NodeKind, type SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedBaseType, SerializedType } from "./Type.ts";
+export interface SerializedEnumType<T extends Record<string, SerializedEnumCaseDecl> = Record<string, SerializedEnumCaseDecl>> extends SerializedBaseType {
+    kind: NodeKind["EnumType"];
+    values: T;
+}
+export interface SerializedEnumCaseDecl<T extends SerializedType | null = SerializedType | null> {
+    kind: NodeKind["EnumCaseDecl"];
+    type: T;
+    comment?: string;
+    isDeprecated?: boolean;
+}
+export declare const resolveTypeArgumentsInSerializedEnumType: SerializedTypeArgumentsResolver<SerializedEnumType>;
+export declare const getReferencesForSerializedEnumType: GetReferencesSerialized<SerializedEnumType>;

package/dist/src/shared/schema/types/EnumType.js

@@ -0,0 +1,28 @@
+import { discriminatorKey } from "../../enum.js";
+import { getReferencesSerialized, resolveSerializedTypeArguments, } from "../Node.js";
+export const resolveTypeArgumentsInSerializedEnumType = (decls, args, type) => ({
+    ...type,
+    values: Object.fromEntries(Object.entries(type.values).map(([key, { type, ...caseMember }]) => [
+        key,
+        {
+            ...caseMember,
+            type: type === null ? null : resolveSerializedTypeArguments(decls, args, type),
+        },
+    ])),
+});
+export const getReferencesForSerializedEnumType = (decls, type, value) => {
+    if (typeof value !== "object" ||
+        value === null ||
+        Array.isArray(value) ||
+        !(discriminatorKey in value)) {
+        return [];
+    }
+    const enumCase = value[discriminatorKey];
+    return typeof enumCase === "string" &&
+        enumCase in type.values &&
+        type.values[enumCase] !== undefined &&
+        type.values[enumCase].type !== null &&
+        enumCase in value
+        ? getReferencesSerialized(decls, type.values[enumCase].type, value[enumCase])
+        : [];
+};

package/dist/src/shared/schema/types/FloatType.d.ts

@@ -0,0 +1,11 @@
+import type { RangeBound } from "../../validation/number.ts";
+import type { GetReferencesSerialized, NodeKind, SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedBaseType } from "./Type.ts";
+export interface SerializedFloatType extends SerializedBaseType {
+    kind: NodeKind["FloatType"];
+    minimum?: RangeBound;
+    maximum?: RangeBound;
+    multipleOf?: number;
+}
+export declare const resolveTypeArgumentsInSerializedFloatType: SerializedTypeArgumentsResolver<SerializedFloatType>;
+export declare const getReferencesForSerializedFloatType: GetReferencesSerialized<SerializedFloatType>;

package/dist/src/shared/schema/types/FloatType.js

@@ -0,0 +1,2 @@
+export const resolveTypeArgumentsInSerializedFloatType = (_decls, _args, type) => type;
+export const getReferencesForSerializedFloatType = () => [];

package/dist/src/shared/schema/types/IncludeIdentifierType.d.ts

@@ -0,0 +1,11 @@
+import { type SerializedDecl, type SerializedTypeArguments } from "../declarations/Declaration.ts";
+import { type GetReferencesSerialized, type NodeKind } from "../Node.ts";
+import type { SerializedTypeParameter } from "../TypeParameter.ts";
+import type { SerializedBaseType, SerializedType } from "./Type.ts";
+export interface SerializedIncludeIdentifierType<Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> extends SerializedBaseType {
+    kind: NodeKind["IncludeIdentifierType"];
+    reference: string;
+    args: SerializedTypeArguments<Params>;
+}
+export declare const resolveTypeArgumentsInSerializedIncludeIdentifierType: <T extends SerializedIncludeIdentifierType>(decls: Record<string, SerializedDecl>, args: Record<string, SerializedType>, type: T) => T extends SerializedIncludeIdentifierType<[]> ? T : SerializedType;
+export declare const getReferencesForSerializedIncludeIdentifierType: GetReferencesSerialized<SerializedIncludeIdentifierType>;

package/dist/src/shared/schema/types/IncludeIdentifierType.js

@@ -0,0 +1,13 @@
+import { getSerializedTypeArgumentsRecord, } from "../declarations/Declaration.js";
+import { getDecl, getReferencesSerialized, resolveSerializedTypeArguments, } from "../Node.js";
+const isNoGenericSerializedIncludeIdentifierType = (node) => node.args.length === 0;
+export const resolveTypeArgumentsInSerializedIncludeIdentifierType = ((decls, args, type) => {
+    const reference = getDecl(decls, type.reference);
+    return (isNoGenericSerializedIncludeIdentifierType(type)
+        ? type
+        : resolveSerializedTypeArguments(decls, getSerializedTypeArgumentsRecord(reference, type.args.map(arg => resolveSerializedTypeArguments(decls, args, arg))), reference).type);
+});
+export const getReferencesForSerializedIncludeIdentifierType = (decls, type, value) => {
+    const reference = getDecl(decls, type.reference);
+    return getReferencesSerialized(decls, resolveSerializedTypeArguments(decls, getSerializedTypeArgumentsRecord(reference, type.args), reference), value);
+};

package/dist/src/shared/schema/types/IntegerType.d.ts

@@ -0,0 +1,11 @@
+import type { RangeBound } from "../../validation/number.ts";
+import type { GetReferencesSerialized, NodeKind, SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedBaseType } from "./Type.ts";
+export interface SerializedIntegerType extends SerializedBaseType {
+    kind: NodeKind["IntegerType"];
+    minimum?: RangeBound;
+    maximum?: RangeBound;
+    multipleOf?: number;
+}
+export declare const resolveTypeArgumentsInSerializedIntegerType: SerializedTypeArgumentsResolver<SerializedIntegerType>;
+export declare const getReferencesForSerializedIntegerType: GetReferencesSerialized<SerializedIntegerType>;

package/dist/src/shared/schema/types/IntegerType.js

@@ -0,0 +1,2 @@
+export const resolveTypeArgumentsInSerializedIntegerType = (_decls, _args, type) => type;
+export const getReferencesForSerializedIntegerType = () => [];

package/dist/src/shared/schema/types/NestedEntityMapType.d.ts

@@ -0,0 +1,17 @@
+import type { NodeKind } from "../Node.ts";
+import { type GetReferencesSerialized, type SerializedTypeArgumentsResolver } from "../Node.ts";
+import { type SerializedIncludeIdentifierType } from "./IncludeIdentifierType.ts";
+import { type SerializedMemberDecl, type SerializedObjectType } from "./ObjectType.ts";
+import type { SerializedBaseType } from "./Type.ts";
+type TSerializedConstraint = Record<string, SerializedMemberDecl>;
+type PossibleType<T extends TSerializedConstraint> = SerializedObjectType<T> | SerializedIncludeIdentifierType<[]>;
+export interface SerializedNestedEntityMapType<Name extends string = string, T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
+    kind: NodeKind["NestedEntityMapType"];
+    name: Name;
+    comment?: string;
+    secondaryEntity: string;
+    type: PossibleType<T>;
+}
+export declare const resolveTypeArgumentsInSerializedNestedEntityMapType: SerializedTypeArgumentsResolver<SerializedNestedEntityMapType>;
+export declare const getReferencesForSerializedNestedEntityMapType: GetReferencesSerialized<SerializedNestedEntityMapType>;
+export {};

package/dist/src/shared/schema/types/NestedEntityMapType.js

@@ -0,0 +1,14 @@
+import { resolveSerializedTypeArguments, } from "../Node.js";
+import { getReferencesForSerializedIncludeIdentifierType, } from "./IncludeIdentifierType.js";
+import { getReferencesForSerializedObjectType, isSerializedObjectType, } from "./ObjectType.js";
+export const resolveTypeArgumentsInSerializedNestedEntityMapType = (decls, args, type) => ({
+    ...type,
+    type: resolveSerializedTypeArguments(decls, args, type.type),
+});
+export const getReferencesForSerializedNestedEntityMapType = (decls, type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? Object.values(value)
+        .flatMap(item => isSerializedObjectType(type.type)
+        ? getReferencesForSerializedObjectType(decls, type.type, item)
+        : getReferencesForSerializedIncludeIdentifierType(decls, type.type, item))
+        .concat(Object.keys(value))
+    : [];

package/dist/src/shared/schema/types/ObjectType.d.ts

@@ -0,0 +1,19 @@
+import type { ObjectConstraints } from "../../validation/object.ts";
+import { NodeKind, type GetReferencesSerialized, type SerializedNode, type SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedBaseType, SerializedType } from "./Type.ts";
+type TSerializedConstraint = Record<string, SerializedMemberDecl>;
+export interface SerializedObjectType<T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType, ObjectConstraints {
+    kind: NodeKind["ObjectType"];
+    properties: T;
+}
+export interface SerializedMemberDecl<T extends SerializedType = SerializedType, R extends boolean = boolean> {
+    kind: NodeKind["MemberDecl"];
+    isRequired: R;
+    type: T;
+    comment?: string;
+    isDeprecated?: boolean;
+}
+export declare const isSerializedObjectType: (type: SerializedNode) => type is SerializedObjectType;
+export declare const resolveTypeArgumentsInSerializedObjectType: SerializedTypeArgumentsResolver<SerializedObjectType>;
+export declare const getReferencesForSerializedObjectType: GetReferencesSerialized<SerializedObjectType>;
+export {};

package/dist/src/shared/schema/types/ObjectType.js

@@ -0,0 +1,14 @@
+import { getReferencesSerialized, NodeKind, resolveSerializedTypeArguments, } from "../Node.js";
+export const isSerializedObjectType = (type) => type.kind === NodeKind.ObjectType;
+export const resolveTypeArgumentsInSerializedObjectType = (decls, args, type) => ({
+    ...type,
+    properties: Object.fromEntries(Object.entries(type.properties).map(([key, config]) => [
+        key,
+        { ...config, type: resolveSerializedTypeArguments(decls, args, config.type) },
+    ])),
+});
+export const getReferencesForSerializedObjectType = (decls, type, value) => typeof value === "object" && value !== null
+    ? Object.entries(value).flatMap(([key, propValue]) => type.properties[key]
+        ? getReferencesSerialized(decls, type.properties[key].type, propValue)
+        : [])
+    : [];

package/dist/src/shared/schema/types/ReferenceIdentifierType.d.ts

@@ -0,0 +1,8 @@
+import type { GetReferencesSerialized, NodeKind, SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedBaseType } from "./Type.ts";
+export interface SerializedReferenceIdentifierType extends SerializedBaseType {
+    kind: NodeKind["ReferenceIdentifierType"];
+    entity: string;
+}
+export declare const resolveTypeArgumentsInSerializedReferenceIdentifierType: SerializedTypeArgumentsResolver<SerializedReferenceIdentifierType>;
+export declare const getReferencesForSerializedReferenceIdentifierType: GetReferencesSerialized<SerializedReferenceIdentifierType>;

package/dist/src/shared/schema/types/ReferenceIdentifierType.js

@@ -0,0 +1,2 @@
+export const resolveTypeArgumentsInSerializedReferenceIdentifierType = (_decls, _args, type) => type;
+export const getReferencesForSerializedReferenceIdentifierType = (_decls, _type, value) => (typeof value === "string" ? [value] : []);

package/dist/src/shared/schema/types/StringType.d.ts

@@ -0,0 +1,10 @@
+import type { StringConstraints } from "../../validation/string.ts";
+import type { GetReferencesSerialized, NodeKind, SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedBaseType } from "./Type.ts";
+export interface SerializedStringType extends SerializedBaseType, StringConstraints {
+    kind: NodeKind["StringType"];
+    pattern?: string;
+    isMarkdown?: boolean;
+}
+export declare const resolveTypeArgumentsInSerializedStringType: SerializedTypeArgumentsResolver<SerializedStringType>;
+export declare const getReferencesForSerializedStringType: GetReferencesSerialized<SerializedStringType>;

package/dist/src/shared/schema/types/StringType.js

@@ -0,0 +1,2 @@
+export const resolveTypeArgumentsInSerializedStringType = (_decls, _args, type) => type;
+export const getReferencesForSerializedStringType = () => [];

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

@@ -0,0 +1,20 @@
+import type { BaseNode } from "../Node.ts";
+import type { SerializedArrayType } from "./ArrayType.ts";
+import type { SerializedBooleanType } from "./BooleanType.ts";
+import type { SerializedChildEntitiesType } from "./ChildEntitiesType.ts";
+import type { SerializedDateType } from "./DateType.ts";
+import type { SerializedEnumType } from "./EnumType.ts";
+import type { SerializedFloatType } from "./FloatType.ts";
+import type { SerializedIncludeIdentifierType } from "./IncludeIdentifierType.ts";
+import type { SerializedIntegerType } from "./IntegerType.ts";
+import type { SerializedNestedEntityMapType } from "./NestedEntityMapType.ts";
+import type { SerializedMemberDecl, SerializedObjectType } from "./ObjectType.ts";
+import type { SerializedReferenceIdentifierType } from "./ReferenceIdentifierType.ts";
+import type { SerializedStringType } from "./StringType.ts";
+import type { SerializedTypeArgumentType } from "./TypeArgumentType.ts";
+export interface SerializedBaseType extends BaseNode {
+}
+export type SerializedType = SerializedBooleanType | SerializedDateType | SerializedFloatType | SerializedIntegerType | SerializedStringType | SerializedArrayType | SerializedObjectType | SerializedTypeArgumentType | SerializedReferenceIdentifierType | SerializedIncludeIdentifierType | SerializedNestedEntityMapType | SerializedEnumType | SerializedChildEntitiesType;
+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 : T extends SerializedChildEntitiesType ? unknown : never;

package/dist/src/shared/schema/types/TypeArgumentType.d.ts

@@ -0,0 +1,12 @@
+import type { SerializedDecl } from "../declarations/Declaration.ts";
+import type { GetReferencesSerialized, NodeKind } from "../Node.ts";
+import type { SerializedTypeParameter } from "../TypeParameter.ts";
+import type { SerializedBaseType, SerializedType } from "./Type.ts";
+type TSerializedConstraint = SerializedTypeParameter;
+export interface SerializedTypeArgumentType<T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
+    kind: NodeKind["TypeArgumentType"];
+    argument: T;
+}
+export declare const resolveTypeArgumentsInSerializedTypeArgumentType: <T extends TSerializedConstraint, Args extends Record<string, SerializedType>>(_decls: Record<string, SerializedDecl>, args: Args, type: SerializedTypeArgumentType<T>) => Args[T["name"]];
+export declare const getReferencesForSerializedTypeArgumentType: GetReferencesSerialized<SerializedTypeArgumentType>;
+export {};

package/dist/src/shared/schema/types/TypeArgumentType.js

@@ -0,0 +1,7 @@
+export const resolveTypeArgumentsInSerializedTypeArgumentType = ((_decls, args, type) => {
+    if (!(type.argument.name in args)) {
+        throw new TypeError(`no generic argument provided for "${type.argument.name}"`);
+    }
+    return args[type.argument.name];
+});
+export const getReferencesForSerializedTypeArgumentType = () => [];

package/dist/src/shared/utils/array.d.ts

@@ -18,3 +18,7 @@ export interface ArrayDiffResult<T> {
     removed: T[];
 }
 export declare const unique: <T>(arr: T[], equalityCheck?: (a: T, b: T) => boolean) => T[];
+/**
+ * Moves an element from one position to another within the array.
+ */
+export declare const reorder: <T>(arr: T[], sourceIndex: number, targetIndex: number) => T[];