tsondb 0.2.0 → 0.4.0

package/lib/{schema → node/schema}/declarations/EntityDecl.d.ts

@@ -1,14 +1,16 @@
-import { Lazy } from "../../utils/lazy.js";
-import { Leaves } from "../../utils/object.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../Node.js";
-import { MemberDecl, ObjectType, SerializedObjectType } from "../types/generic/ObjectType.js";
+import { Lazy } from "../../../shared/utils/lazy.js";
+import type { Leaves } from "../../../shared/utils/object.js";
+import type { GetReferences, Node, Serializer } from "../Node.js";
+import { NodeKind } from "../Node.js";
+import type { MemberDecl, ObjectType, SerializedObjectType } from "../types/generic/ObjectType.js";
 import { StringType } from "../types/primitives/StringType.js";
-import { AsType, SerializedAsType, Type } from "../types/Type.js";
-import { ValidatorHelpers } from "../validation/type.js";
-import { BaseDecl, GetNestedDeclarations, SerializedBaseDecl } from "./Declaration.js";
+import type { AsType, SerializedAsType } from "../types/Type.js";
+import type { ValidatorHelpers } from "../validation/type.js";
+import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl } from "./Declaration.js";
 import { TypeAliasDecl } from "./TypeAliasDecl.js";
 export interface EntityDecl<Name extends string = string, T extends ObjectType = ObjectType> extends BaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
+    namePlural: string;
     type: Lazy<T>;
     /**
      * @default "name"
@@ -27,6 +29,7 @@ export interface EntityDecl<Name extends string = string, T extends ObjectType =
 }
 export interface SerializedEntityDecl<Name extends string = string, T extends SerializedObjectType = SerializedObjectType> extends SerializedBaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
+    namePlural: string;
     type: T;
     /**
      * @default "name"
@@ -45,6 +48,7 @@ export interface SerializedEntityDecl<Name extends string = string, T extends Se
 }
 export declare const EntityDecl: <Name extends string, T extends ObjectType>(sourceUrl: string, options: {
     name: Name;
+    namePlural: string;
     comment?: string;
     type: () => T;
     /**
@@ -67,10 +71,10 @@ export declare const isEntityDecl: (node: Node) => node is EntityDecl;
 export declare const getNestedDeclarationsInEntityDecl: GetNestedDeclarations<EntityDecl>;
 export declare const validateEntityDecl: (helpers: ValidatorHelpers, decl: EntityDecl, value: unknown) => Error[];
 export declare const resolveTypeArgumentsInEntityDecl: (decl: EntityDecl) => EntityDecl;
-export declare const addEphemeralUUIDToType: <T extends Record<string, MemberDecl<Type, boolean>>>(decl: EntityDecl<string, ObjectType<T>>) => ObjectType<Omit<T, "id"> & {
+export declare const addEphemeralUUIDToType: <T extends Record<string, MemberDecl>>(decl: EntityDecl<string, ObjectType<T>>) => ObjectType<Omit<T, "id"> & {
     id: MemberDecl<StringType, true>;
 }>;
 export declare const createEntityIdentifierType: () => StringType;
-export declare const createEntityIdentifierTypeAsDecl: <Name extends string>(decl: EntityDecl<Name, ObjectType>) => TypeAliasDecl<`${Name}_ID`, StringType, []>;
+export declare const createEntityIdentifierTypeAsDecl: <Name extends string>(decl: EntityDecl<Name>) => TypeAliasDecl<`${Name}_ID`, StringType, []>;
 export declare const serializeEntityDecl: Serializer<EntityDecl, SerializedEntityDecl>;
 export declare const getReferencesForEntityDecl: GetReferences<EntityDecl>;

package/lib/{schema → node/schema}/declarations/EntityDecl.js

@@ -1,9 +1,9 @@
-import { Lazy } from "../../utils/lazy.js";
+import { Lazy } from "../../../shared/utils/lazy.js";
 import { NodeKind } from "../Node.js";
 import { getNestedDeclarationsInObjectType, getReferencesForObjectType, Required, resolveTypeArgumentsInObjectType, serializeObjectType, } from "../types/generic/ObjectType.js";
 import { StringType } from "../types/primitives/StringType.js";
 import { validate } from "../types/Type.js";
-import { validateDeclName, } from "./Declaration.js";
+import { validateDeclName } from "./Declaration.js";
 import { TypeAliasDecl } from "./TypeAliasDecl.js";
 export const EntityDecl = (sourceUrl, options) => {
     validateDeclName(options.name);

package/lib/{schema → node/schema}/declarations/EnumDecl.d.ts

@@ -1,17 +1,20 @@
-import { Lazy } from "../../utils/lazy.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../Node.js";
-import { SerializedTypeParameter, TypeParameter } from "../parameters/TypeParameter.js";
-import { SerializedType, Type } from "../types/Type.js";
-import { ValidatorHelpers } from "../validation/type.js";
-import { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.js";
+import { Lazy } from "../../../shared/utils/lazy.js";
+import type { GetReferences, Node, Serializer } from "../Node.js";
+import { NodeKind } from "../Node.js";
+import type { SerializedTypeParameter, TypeParameter } from "../TypeParameter.js";
+import type { EnumCaseDecl, SerializedEnumCaseDecl, SerializedEnumType } from "../types/generic/EnumType.js";
+import { EnumType } from "../types/generic/EnumType.js";
+import type { Type } from "../types/Type.js";
+import type { ValidatorHelpers } from "../validation/type.js";
+import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.js";
 export interface EnumDecl<Name extends string = string, T extends Record<string, EnumCaseDecl> = Record<string, EnumCaseDecl>, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
     kind: NodeKind["EnumDecl"];
-    values: Lazy<T>;
+    type: Lazy<EnumType<T>>;
     isDeprecated?: boolean;
 }
 export interface SerializedEnumDecl<Name extends string = string, T extends Record<string, SerializedEnumCaseDecl> = Record<string, SerializedEnumCaseDecl>, Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> extends SerializedBaseDecl<Name, Params> {
     kind: NodeKind["EnumDecl"];
-    values: T;
+    type: SerializedEnumType<T>;
     isDeprecated?: boolean;
 }
 export declare const GenEnumDecl: <Name extends string, T extends Record<string, EnumCaseDecl>, Params extends TypeParameter[]>(sourceUrl: string, options: {
@@ -31,23 +34,5 @@ export declare const isEnumDecl: (node: Node) => node is EnumDecl;
 export declare const getNestedDeclarationsInEnumDecl: GetNestedDeclarations<EnumDecl>;
 export declare const validateEnumDecl: (helpers: ValidatorHelpers, decl: EnumDecl, args: Type[], value: unknown) => Error[];
 export declare const resolveTypeArgumentsInEnumDecl: <Params extends TypeParameter[]>(decl: EnumDecl<string, Record<string, EnumCaseDecl>, Params>, args: TypeArguments<Params>) => EnumDecl<string, Record<string, EnumCaseDecl>, []>;
-export interface EnumCaseDecl<T extends Type | null = Type | null> {
-    kind: NodeKind["EnumCaseDecl"];
-    type: T;
-    comment?: string;
-    isDeprecated?: boolean;
-}
-export interface SerializedEnumCaseDecl<T extends SerializedType | null = SerializedType | null> {
-    kind: NodeKind["EnumCaseDecl"];
-    type: T;
-    comment?: string;
-    isDeprecated?: boolean;
-}
-export declare const EnumCaseDecl: <T extends Type | null>(options: {
-    type: T;
-    comment?: string;
-    isDeprecated?: boolean;
-}) => EnumCaseDecl<T>;
-export { EnumCaseDecl as EnumCase };
 export declare const serializeEnumDecl: Serializer<EnumDecl, SerializedEnumDecl>;
 export declare const getReferencesForEnumDecl: GetReferences<EnumDecl>;

package/lib/node/schema/declarations/EnumDecl.js

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

package/lib/{schema → node/schema}/declarations/TypeAliasDecl.d.ts

@@ -1,9 +1,10 @@
-import { Lazy } from "../../utils/lazy.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../Node.js";
-import { SerializedTypeParameter, TypeParameter } from "../parameters/TypeParameter.js";
-import { SerializedType, Type } from "../types/Type.js";
-import { ValidatorHelpers } from "../validation/type.js";
-import { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.js";
+import { Lazy } from "../../../shared/utils/lazy.js";
+import type { GetReferences, Node, Serializer } from "../Node.js";
+import { NodeKind } from "../Node.js";
+import type { SerializedTypeParameter, TypeParameter } from "../TypeParameter.js";
+import type { SerializedType, Type } from "../types/Type.js";
+import type { ValidatorHelpers } from "../validation/type.js";
+import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.js";
 export interface TypeAliasDecl<Name extends string = string, T extends Type = Type, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
     kind: NodeKind["TypeAliasDecl"];
     type: Lazy<T>;
@@ -29,7 +30,7 @@ export declare const TypeAliasDecl: <Name extends string, T extends Type>(source
     type: () => T;
 }) => TypeAliasDecl<Name, T, []>;
 export { TypeAliasDecl as TypeAlias };
-export declare const isTypeAliasDecl: (node: Node) => node is TypeAliasDecl<string, Type, TypeParameter[]>;
+export declare const isTypeAliasDecl: (node: Node) => node is TypeAliasDecl;
 export declare const getNestedDeclarationsInTypeAliasDecl: GetNestedDeclarations<TypeAliasDecl>;
 export declare const validateTypeAliasDecl: <Params extends TypeParameter[]>(helpers: ValidatorHelpers, decl: TypeAliasDecl<string, Type, Params>, args: TypeArguments<Params>, value: unknown) => Error[];
 export declare const resolveTypeArgumentsInTypeAliasDecl: <Params extends TypeParameter[]>(decl: TypeAliasDecl<string, Type, Params>, args: TypeArguments<Params>) => TypeAliasDecl<string, Type, []>;

package/lib/{schema → node/schema}/declarations/TypeAliasDecl.js

@@ -1,8 +1,8 @@
-import { Lazy } from "../../utils/lazy.js";
+import { Lazy } from "../../../shared/utils/lazy.js";
 import { NodeKind } from "../Node.js";
-import { serializeTypeParameter, } from "../parameters/TypeParameter.js";
+import { serializeTypeParameter } from "../TypeParameter.js";
 import { getReferencesForType, resolveTypeArgumentsInType, serializeType, validate, } from "../types/Type.js";
-import { getNestedDeclarations, getTypeArgumentsRecord, validateDeclName, } from "./Declaration.js";
+import { getNestedDeclarations, getTypeArgumentsRecord, validateDeclName } from "./Declaration.js";
 export const GenTypeAliasDecl = (sourceUrl, options) => {
     validateDeclName(options.name);
     const decl = {

package/lib/{schema → node/schema}/index.d.ts

@@ -3,18 +3,19 @@ export * from "./declarations/EntityDecl.js";
 export * from "./declarations/EnumDecl.js";
 export * from "./declarations/TypeAliasDecl.js";
 export * from "./Node.js";
-export * from "./parameters/TypeParameter.js";
+export * from "./TypeParameter.js";
 export * from "./types/generic/ArrayType.js";
+export * from "./types/generic/EnumType.js";
 export * from "./types/generic/ObjectType.js";
 export * from "./types/primitives/BooleanType.js";
 export * from "./types/primitives/DateType.js";
 export * from "./types/primitives/FloatType.js";
 export * from "./types/primitives/IntegerType.js";
 export * from "./types/primitives/NumericType.js";
-export * from "./types/primitives/PrimitiveType.js";
+export type * from "./types/primitives/PrimitiveType.js";
 export * from "./types/primitives/StringType.js";
-export * from "./types/references/GenericArgumentIdentifierType.js";
 export * from "./types/references/IncludeIdentifierType.js";
 export * from "./types/references/NestedEntityMapType.js";
 export * from "./types/references/ReferenceIdentifierType.js";
+export * from "./types/references/TypeArgumentType.js";
 export * from "./types/Type.js";

package/lib/{schema → node/schema}/index.js

@@ -3,18 +3,18 @@ export * from "./declarations/EntityDecl.js";
 export * from "./declarations/EnumDecl.js";
 export * from "./declarations/TypeAliasDecl.js";
 export * from "./Node.js";
-export * from "./parameters/TypeParameter.js";
+export * from "./TypeParameter.js";
 export * from "./types/generic/ArrayType.js";
+export * from "./types/generic/EnumType.js";
 export * from "./types/generic/ObjectType.js";
 export * from "./types/primitives/BooleanType.js";
 export * from "./types/primitives/DateType.js";
 export * from "./types/primitives/FloatType.js";
 export * from "./types/primitives/IntegerType.js";
 export * from "./types/primitives/NumericType.js";
-export * from "./types/primitives/PrimitiveType.js";
 export * from "./types/primitives/StringType.js";
-export * from "./types/references/GenericArgumentIdentifierType.js";
 export * from "./types/references/IncludeIdentifierType.js";
 export * from "./types/references/NestedEntityMapType.js";
 export * from "./types/references/ReferenceIdentifierType.js";
+export * from "./types/references/TypeArgumentType.js";
 export * from "./types/Type.js";

package/lib/node/schema/types/Type.d.ts

@@ -0,0 +1,48 @@
+import type { Decl } from "../declarations/Declaration.js";
+import type { BaseNode, GetReferences, Serializer } from "../Node.js";
+import type { Validator } from "../validation/type.js";
+import type { ArrayType, SerializedArrayType } from "./generic/ArrayType.js";
+import type { EnumType, SerializedEnumType } from "./generic/EnumType.js";
+import type { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "./generic/ObjectType.js";
+import type { BooleanType, SerializedBooleanType } from "./primitives/BooleanType.js";
+import type { DateType, SerializedDateType } from "./primitives/DateType.js";
+import type { FloatType, SerializedFloatType } from "./primitives/FloatType.js";
+import type { IntegerType, SerializedIntegerType } from "./primitives/IntegerType.js";
+import type { PrimitiveType, SerializedPrimitiveType } from "./primitives/PrimitiveType.js";
+import type { SerializedStringType, StringType } from "./primitives/StringType.js";
+import type { IncludeIdentifierType, SerializedIncludeIdentifierType } from "./references/IncludeIdentifierType.js";
+import type { NestedEntityMapType, SerializedNestedEntityMapType } from "./references/NestedEntityMapType.js";
+import type { ReferenceIdentifierType, SerializedReferenceIdentifierType } from "./references/ReferenceIdentifierType.js";
+import type { SerializedTypeArgumentType, TypeArgumentType } from "./references/TypeArgumentType.js";
+export interface BaseType extends BaseNode {
+    /**
+     * The parent node of this type will be set when the type is used in a declaration or nested in another type.
+     */
+    parent?: Type | Decl;
+}
+export interface SerializedBaseType extends BaseNode {
+}
+export type Type = PrimitiveType | ArrayType | ObjectType | TypeArgumentType | ReferenceIdentifierType | IncludeIdentifierType | NestedEntityMapType | EnumType;
+export type SerializedType = SerializedPrimitiveType | SerializedArrayType | SerializedObjectType | SerializedTypeArgumentType | SerializedReferenceIdentifierType | SerializedIncludeIdentifierType | SerializedNestedEntityMapType | SerializedEnumType;
+export declare const validate: Validator<Type>;
+export declare const resolveTypeArgumentsInType: (args: Record<string, Type>, type: Type) => Type;
+export declare function walkTypeNodeTree(callbackFn: (type: Type) => void, type: Type): void;
+export type AsType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? {
+    [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsType<P[K]["type"]> : AsType<P[K]["type"]> | undefined;
+} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType ? unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? unknown : never;
+export type SerializedAsType<T extends SerializedType> = T extends SerializedArrayType<infer I> ? SerializedAsType<I>[] : T extends SerializedObjectType<infer P> ? {
+    [K in keyof P]: P[K] extends SerializedMemberDecl<SerializedType, true> ? SerializedAsType<P[K]["type"]> : SerializedAsType<P[K]["type"]> | undefined;
+} : T extends SerializedBooleanType ? boolean : T extends SerializedDateType ? Date : T extends SerializedFloatType ? number : T extends SerializedIntegerType ? number : T extends SerializedStringType ? string : T extends SerializedTypeArgumentType ? unknown : T extends SerializedIncludeIdentifierType ? unknown : T extends SerializedNestedEntityMapType ? unknown : T extends SerializedReferenceIdentifierType ? unknown : never;
+export type AsNode<T> = T extends (infer I)[] ? ArrayType<AsNode<I>> : T extends Record<string, unknown> ? ObjectType<{
+    [K in keyof T]: T[K] extends MemberDecl ? T[K] : T extends null | undefined ? MemberDecl<AsNode<NonNullable<T[K]>>, false> : MemberDecl<AsNode<T[K]>, true>;
+}> : T extends string ? StringType : T extends number ? FloatType : T extends boolean ? BooleanType : never;
+export declare const getParentDecl: (type: Type) => Decl | undefined;
+export declare const findTypeAtPath: (type: Type, path: string[]) => Type | undefined;
+export declare const serializeType: Serializer<Type, SerializedType>;
+export declare const removeParentKey: <T extends BaseType>(type: T) => Omit<T, "parent">;
+export declare const getReferencesForType: GetReferences<Type>;
+/**
+ * Format the structure of a value to always look the same when serialized as JSON.
+ */
+export type StructureFormatter<T extends Type> = (type: T, value: unknown) => unknown;
+export declare const formatValue: StructureFormatter<Type>;

package/lib/{schema → node/schema}/types/Type.js

@@ -1,17 +1,18 @@
-import { assertExhaustive } from "../../shared/utils/typeSafety.js";
+import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { isDecl } from "../declarations/Declaration.js";
 import { NodeKind } from "../Node.js";
-import { getReferencesForArrayType, resolveTypeArgumentsInArrayType, serializeArrayType, validateArrayType, } from "./generic/ArrayType.js";
-import { getReferencesForObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, validateObjectType, } from "./generic/ObjectType.js";
-import { getReferencesForBooleanType, serializeBooleanType, validateBooleanType, } from "./primitives/BooleanType.js";
-import { getReferencesForDateType, serializeDateType, validateDateType, } from "./primitives/DateType.js";
-import { getReferencesForFloatType, serializeFloatType, validateFloatType, } from "./primitives/FloatType.js";
-import { getReferencesForIntegerType, serializeIntegerType, validateIntegerType, } from "./primitives/IntegerType.js";
-import { getReferencesForStringType, serializeStringType, validateStringType, } from "./primitives/StringType.js";
-import { getReferencesForGenericArgumentIdentifierType, resolveTypeArgumentsInGenericArgumentIdentifierType, serializeGenericArgumentIdentifierType, validateGenericArgumentIdentifierType, } from "./references/GenericArgumentIdentifierType.js";
-import { getReferencesForIncludeIdentifierType, resolveTypeArgumentsInIncludeIdentifierType, serializeIncludeIdentifierType, validateIncludeIdentifierType, } from "./references/IncludeIdentifierType.js";
-import { getReferencesForNestedEntityMapType, resolveTypeArgumentsInNestedEntityMapType, serializeNestedEntityMapType, validateNestedEntityMapType, } from "./references/NestedEntityMapType.js";
-import { getReferencesForReferenceIdentifierType, resolveTypeArgumentsInReferenceIdentifierType, serializeReferenceIdentifierType, validateReferenceIdentifierType, } from "./references/ReferenceIdentifierType.js";
+import { formatArrayValue, getReferencesForArrayType, resolveTypeArgumentsInArrayType, serializeArrayType, validateArrayType, } from "./generic/ArrayType.js";
+import { formatEnumType, getReferencesForEnumType, resolveTypeArgumentsInEnumType, serializeEnumType, validateEnumType, } from "./generic/EnumType.js";
+import { formatObjectValue, getReferencesForObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, validateObjectType, } from "./generic/ObjectType.js";
+import { formatBooleanValue, getReferencesForBooleanType, serializeBooleanType, validateBooleanType, } from "./primitives/BooleanType.js";
+import { formatDateValue, getReferencesForDateType, serializeDateType, validateDateType, } from "./primitives/DateType.js";
+import { formatFloatValue, getReferencesForFloatType, serializeFloatType, validateFloatType, } from "./primitives/FloatType.js";
+import { formatIntegerValue, getReferencesForIntegerType, serializeIntegerType, validateIntegerType, } from "./primitives/IntegerType.js";
+import { formatStringValue, getReferencesForStringType, serializeStringType, validateStringType, } from "./primitives/StringType.js";
+import { formatIncludeIdentifierValue, getReferencesForIncludeIdentifierType, resolveTypeArgumentsInIncludeIdentifierType, serializeIncludeIdentifierType, validateIncludeIdentifierType, } from "./references/IncludeIdentifierType.js";
+import { formatNestedEntityMapValue, getReferencesForNestedEntityMapType, resolveTypeArgumentsInNestedEntityMapType, serializeNestedEntityMapType, validateNestedEntityMapType, } from "./references/NestedEntityMapType.js";
+import { formatReferenceIdentifierValue, getReferencesForReferenceIdentifierType, resolveTypeArgumentsInReferenceIdentifierType, serializeReferenceIdentifierType, validateReferenceIdentifierType, } from "./references/ReferenceIdentifierType.js";
+import { formatTypeArgumentValue, getReferencesForTypeArgumentType, resolveTypeArgumentsInTypeArgumentType, serializeTypeArgumentType, validateTypeArgumentType, } from "./references/TypeArgumentType.js";
 export const validate = (helpers, type, value) => {
     switch (type.kind) {
         case NodeKind.ArrayType:
@@ -28,14 +29,16 @@ export const validate = (helpers, type, value) => {
             return validateIntegerType(helpers, type, value);
         case NodeKind.StringType:
             return validateStringType(helpers, type, value);
-        case NodeKind.GenericArgumentIdentifierType:
-            return validateGenericArgumentIdentifierType(helpers, type, value);
+        case NodeKind.TypeArgumentType:
+            return validateTypeArgumentType(helpers, type, value);
         case NodeKind.ReferenceIdentifierType:
             return validateReferenceIdentifierType(helpers, type, value);
         case NodeKind.IncludeIdentifierType:
             return validateIncludeIdentifierType(helpers, type, value);
         case NodeKind.NestedEntityMapType:
             return validateNestedEntityMapType(helpers, type, value);
+        case NodeKind.EnumType:
+            return validateEnumType(helpers, type, value);
         default:
             return assertExhaustive(type);
     }
@@ -52,14 +55,16 @@ export const resolveTypeArgumentsInType = (args, type) => {
         case NodeKind.IntegerType:
         case NodeKind.StringType:
             return type;
-        case NodeKind.GenericArgumentIdentifierType:
-            return resolveTypeArgumentsInGenericArgumentIdentifierType(args, type);
+        case NodeKind.TypeArgumentType:
+            return resolveTypeArgumentsInTypeArgumentType(args, type);
         case NodeKind.ReferenceIdentifierType:
             return resolveTypeArgumentsInReferenceIdentifierType(args, type);
         case NodeKind.IncludeIdentifierType:
             return resolveTypeArgumentsInIncludeIdentifierType(args, type);
         case NodeKind.NestedEntityMapType:
             return resolveTypeArgumentsInNestedEntityMapType(args, type);
+        case NodeKind.EnumType:
+            return resolveTypeArgumentsInEnumType(args, type);
         default:
             return assertExhaustive(type);
     }
@@ -68,22 +73,45 @@ export function walkTypeNodeTree(callbackFn, type) {
     switch (type.kind) {
         case NodeKind.ArrayType:
             callbackFn(type);
-            return walkTypeNodeTree(callbackFn, type.items);
+            {
+                walkTypeNodeTree(callbackFn, type.items);
+                return;
+            }
         case NodeKind.ObjectType:
             callbackFn(type);
-            return Object.values(type.properties).forEach(prop => walkTypeNodeTree(callbackFn, prop.type));
+            {
+                Object.values(type.properties).forEach(prop => {
+                    walkTypeNodeTree(callbackFn, prop.type);
+                });
+                return;
+            }
         case NodeKind.NestedEntityMapType:
             callbackFn(type);
-            return walkTypeNodeTree(callbackFn, type.type.value);
+            {
+                walkTypeNodeTree(callbackFn, type.type.value);
+                return;
+            }
         case NodeKind.BooleanType:
         case NodeKind.DateType:
         case NodeKind.FloatType:
         case NodeKind.IntegerType:
         case NodeKind.StringType:
-        case NodeKind.GenericArgumentIdentifierType:
+        case NodeKind.TypeArgumentType:
         case NodeKind.ReferenceIdentifierType:
-        case NodeKind.IncludeIdentifierType:
-            return callbackFn(type);
+        case NodeKind.IncludeIdentifierType: {
+            callbackFn(type);
+            return;
+        }
+        case NodeKind.EnumType:
+            callbackFn(type);
+            {
+                Object.values(type.values).forEach(value => {
+                    if (value.type) {
+                        walkTypeNodeTree(callbackFn, value.type);
+                    }
+                });
+                return;
+            }
         default:
             return assertExhaustive(type);
     }
@@ -100,10 +128,10 @@ export const getParentDecl = (type) => {
     }
 };
 export const findTypeAtPath = (type, path) => {
-    if (path.length === 0) {
+    const [head, ...tail] = path;
+    if (head === undefined) {
         return type;
     }
-    const [head, ...tail] = path;
     if (type.kind === NodeKind.ObjectType) {
         const prop = type.properties[head];
         if (prop) {
@@ -131,14 +159,16 @@ export const serializeType = type => {
             return serializeIntegerType(type);
         case NodeKind.StringType:
             return serializeStringType(type);
-        case NodeKind.GenericArgumentIdentifierType:
-            return serializeGenericArgumentIdentifierType(type);
+        case NodeKind.TypeArgumentType:
+            return serializeTypeArgumentType(type);
         case NodeKind.ReferenceIdentifierType:
             return serializeReferenceIdentifierType(type);
         case NodeKind.IncludeIdentifierType:
             return serializeIncludeIdentifierType(type);
         case NodeKind.NestedEntityMapType:
             return serializeNestedEntityMapType(type);
+        case NodeKind.EnumType:
+            return serializeEnumType(type);
         default:
             return assertExhaustive(type);
     }
@@ -163,14 +193,46 @@ export const getReferencesForType = (type, value) => {
             return getReferencesForIntegerType(type, value);
         case NodeKind.StringType:
             return getReferencesForStringType(type, value);
-        case NodeKind.GenericArgumentIdentifierType:
-            return getReferencesForGenericArgumentIdentifierType(type, value);
+        case NodeKind.TypeArgumentType:
+            return getReferencesForTypeArgumentType(type, value);
         case NodeKind.ReferenceIdentifierType:
             return getReferencesForReferenceIdentifierType(type, value);
         case NodeKind.IncludeIdentifierType:
             return getReferencesForIncludeIdentifierType(type, value);
         case NodeKind.NestedEntityMapType:
             return getReferencesForNestedEntityMapType(type, value);
+        case NodeKind.EnumType:
+            return getReferencesForEnumType(type, value);
+        default:
+            return assertExhaustive(type);
+    }
+};
+export const formatValue = (type, value) => {
+    switch (type.kind) {
+        case NodeKind.ArrayType:
+            return formatArrayValue(type, value);
+        case NodeKind.ObjectType:
+            return formatObjectValue(type, value);
+        case NodeKind.BooleanType:
+            return formatBooleanValue(type, value);
+        case NodeKind.DateType:
+            return formatDateValue(type, value);
+        case NodeKind.FloatType:
+            return formatFloatValue(type, value);
+        case NodeKind.IntegerType:
+            return formatIntegerValue(type, value);
+        case NodeKind.StringType:
+            return formatStringValue(type, value);
+        case NodeKind.TypeArgumentType:
+            return formatTypeArgumentValue(type, value);
+        case NodeKind.IncludeIdentifierType:
+            return formatIncludeIdentifierValue(type, value);
+        case NodeKind.NestedEntityMapType:
+            return formatNestedEntityMapValue(type, value);
+        case NodeKind.ReferenceIdentifierType:
+            return formatReferenceIdentifierValue(type, value);
+        case NodeKind.EnumType:
+            return formatEnumType(type, value);
         default:
             return assertExhaustive(type);
     }

package/lib/{schema → node/schema}/types/generic/ArrayType.d.ts

@@ -1,7 +1,8 @@
-import { GetNestedDeclarations } from "../../declarations/Declaration.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, SerializedType, Type } from "../Type.js";
+import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
 export interface ArrayType<T extends Type = Type> extends BaseType {
     kind: NodeKind["ArrayType"];
     minItems?: number;
@@ -28,3 +29,4 @@ export declare const validateArrayType: Validator<ArrayType>;
 export declare const resolveTypeArgumentsInArrayType: (args: Record<string, Type>, type: ArrayType) => ArrayType;
 export declare const serializeArrayType: Serializer<ArrayType, SerializedArrayType>;
 export declare const getReferencesForArrayType: GetReferences<ArrayType>;
+export declare const formatArrayValue: StructureFormatter<ArrayType>;

package/lib/{schema → node/schema}/types/generic/ArrayType.js

@@ -1,10 +1,10 @@
-import { parallelizeErrors } from "../../../shared/utils/validation.js";
-import { validateArrayConstraints } from "../../../shared/validation/array.js";
+import { parallelizeErrors } from "../../../../shared/utils/validation.js";
+import { validateArrayConstraints } from "../../../../shared/validation/array.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
 import { getNestedDeclarations } from "../../declarations/Declaration.js";
 import { NodeKind } from "../../Node.js";
 import { validateOption } from "../../validation/options.js";
-import { getReferencesForType, removeParentKey, resolveTypeArgumentsInType, serializeType, validate, } from "../Type.js";
+import { formatValue, getReferencesForType, removeParentKey, resolveTypeArgumentsInType, serializeType, validate, } from "../Type.js";
 export const ArrayType = (items, options = {}) => {
     const type = {
         ...options,
@@ -25,7 +25,7 @@ export const validateArrayType = (helpers, type, value) => {
     }
     return parallelizeErrors([
         ...validateArrayConstraints(type, value),
-        ...value.map((item, index) => wrapErrorsIfAny(`at index ${index}`, validate(helpers, type.items, item))),
+        ...value.map((item, index) => wrapErrorsIfAny(`at index ${index.toString()}`, validate(helpers, type.items, item))),
     ]);
 };
 export const resolveTypeArgumentsInArrayType = (args, type) => ArrayType(resolveTypeArgumentsInType(args, type.items), {
@@ -36,3 +36,4 @@ export const serializeArrayType = type => ({
     items: serializeType(type.items),
 });
 export const getReferencesForArrayType = (type, value) => Array.isArray(value) ? value.flatMap(item => getReferencesForType(type.items, item)) : [];
+export const formatArrayValue = (type, value) => Array.isArray(value) ? value.map(item => formatValue(type.items, item)) : value;

package/lib/node/schema/types/generic/EnumType.d.ts

@@ -0,0 +1,39 @@
+import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
+export interface EnumType<T extends Record<string, EnumCaseDecl> = Record<string, EnumCaseDecl>> extends BaseType {
+    kind: NodeKind["EnumType"];
+    values: T;
+}
+export interface SerializedEnumType<T extends Record<string, SerializedEnumCaseDecl> = Record<string, SerializedEnumCaseDecl>> extends SerializedBaseType {
+    kind: NodeKind["EnumType"];
+    values: T;
+}
+export declare const EnumType: <T extends Record<string, EnumCaseDecl> = Record<string, EnumCaseDecl>>(values: T) => EnumType<T>;
+export declare const isEnumType: (node: Node) => node is EnumType;
+export declare const getNestedDeclarationsInEnumType: GetNestedDeclarations<EnumType>;
+export declare const validateEnumType: Validator<EnumType>;
+export declare const resolveTypeArgumentsInEnumType: (args: Record<string, Type>, type: EnumType) => EnumType;
+export interface EnumCaseDecl<T extends Type | null = Type | null> {
+    kind: NodeKind["EnumCaseDecl"];
+    type: T;
+    comment?: string;
+    isDeprecated?: boolean;
+}
+export interface SerializedEnumCaseDecl<T extends SerializedType | null = SerializedType | null> {
+    kind: NodeKind["EnumCaseDecl"];
+    type: T;
+    comment?: string;
+    isDeprecated?: boolean;
+}
+export declare const EnumCaseDecl: <T extends Type | null>(options: {
+    type: T;
+    comment?: string;
+    isDeprecated?: boolean;
+}) => EnumCaseDecl<T>;
+export { EnumCaseDecl as EnumCase };
+export declare const serializeEnumType: Serializer<EnumType, SerializedEnumType>;
+export declare const getReferencesForEnumType: GetReferences<EnumType>;
+export declare const formatEnumType: StructureFormatter<EnumType>;