patram 0.11.0 → 0.12.0

package/lib/graph/check-directive-path-target.d.ts

@@ -1,32 +1,25 @@
 /**
  * @param {PatramClaim} claim
  * @param {string} directive_name
- * @param {MappingDefinition | null} mapping_definition
- * @param {Exclude<DirectiveTypeConfig, { type: 'enum' }> | undefined} type_definition
+ * @param {MetadataFieldConfig | undefined} type_definition
  * @param {Map<string, string>} document_entity_keys
  * @param {Map<string, import('./document-node-identity.js').DocumentNodeReference>} document_node_references
  * @param {Set<string>} document_paths
  * @returns {PatramDiagnostic[]}
  */
-export function createPathExistenceDiagnostics(claim: PatramClaim, directive_name: string, mapping_definition: MappingDefinition | null, type_definition: Exclude<DirectiveTypeConfig, {
-    type: "enum";
-}> | undefined, document_entity_keys: Map<string, string>, document_node_references: Map<string, import("./document-node-identity.js").DocumentNodeReference>, document_paths: Set<string>): PatramDiagnostic[];
+export function createPathExistenceDiagnostics(claim: PatramClaim, directive_name: string, type_definition: MetadataFieldConfig | undefined, document_entity_keys: Map<string, string>, document_node_references: Map<string, import("./document-node-identity.js").DocumentNodeReference>, document_paths: Set<string>): PatramDiagnostic[];
 /**
  * @param {PatramClaim} claim
  * @param {string} directive_name
- * @param {Record<string, MappingDefinition>} mappings
- * @param {PatramRepoConfig} repo_config
- * @param {Exclude<DirectiveTypeConfig, { type: 'enum' }>} type_definition
+ * @param {Extract<MetadataFieldConfig, { type: 'ref' }>} type_definition
  * @param {Map<string, string>} document_entity_keys
  * @param {Map<string, import('./document-node-identity.js').DocumentNodeReference>} document_node_references
  * @param {Set<string>} document_paths
  * @returns {PatramDiagnostic[]}
  */
-export function createPathClassDiagnostics(claim: PatramClaim, directive_name: string, mappings: Record<string, MappingDefinition>, repo_config: PatramRepoConfig, type_definition: Exclude<DirectiveTypeConfig, {
-    type: "enum";
+export function createTargetTypeDiagnostics(claim: PatramClaim, directive_name: string, type_definition: Extract<MetadataFieldConfig, {
+    type: "ref";
 }>, document_entity_keys: Map<string, string>, document_node_references: Map<string, import("./document-node-identity.js").DocumentNodeReference>, document_paths: Set<string>): PatramDiagnostic[];
 import type { PatramClaim } from '../parse/parse-claims.types.d.ts';
-import type { MappingDefinition } from '../config/patram-config.types.d.ts';
-import type { DirectiveTypeConfig } from '../config/load-patram-config.types.d.ts';
+import type { MetadataFieldConfig } from '../config/load-patram-config.types.d.ts';
 import type { PatramDiagnostic } from '../config/load-patram-config.types.d.ts';
-import type { PatramRepoConfig } from '../config/load-patram-config.types.d.ts';

package/lib/graph/check-directive-path-target.js

@@ -1,7 +1,6 @@
 /**
- * @import { DirectiveTypeConfig, PatramDiagnostic, PatramRepoConfig } from '../config/load-patram-config.types.ts';
+ * @import { MetadataFieldConfig, PatramDiagnostic } from '../config/load-patram-config.types.ts';
  * @import { PatramClaim } from '../parse/parse-claims.types.ts';
- * @import { MappingDefinition } from '../config/patram-config.types.ts';
  */
 
 import { isPathLikeTarget } from '../parse/claim-helpers.js';
@@ -11,8 +10,7 @@ import { createOriginDiagnostic } from './directive-diagnostics.js';
 /**
  * @param {PatramClaim} claim
  * @param {string} directive_name
- * @param {MappingDefinition | null} mapping_definition
- * @param {Exclude<DirectiveTypeConfig, { type: 'enum' }> | undefined} type_definition
+ * @param {MetadataFieldConfig | undefined} type_definition
  * @param {Map<string, string>} document_entity_keys
  * @param {Map<string, import('./document-node-identity.js').DocumentNodeReference>} document_node_references
  * @param {Set<string>} document_paths
@@ -21,7 +19,6 @@ import { createOriginDiagnostic } from './directive-diagnostics.js';
 export function createPathExistenceDiagnostics(
   claim,
   directive_name,
-  mapping_definition,
   type_definition,
   document_entity_keys,
   document_node_references,
@@ -30,14 +27,14 @@ export function createPathExistenceDiagnostics(
   if (
     typeof claim.value !== 'string' ||
     !isPathLikeTarget(claim.value) ||
-    !shouldCheckDirectivePathExistence(mapping_definition, type_definition)
+    !shouldCheckDirectivePathExistence(type_definition)
   ) {
     return [];
   }
 
   const resolved_target = resolveDirectiveTargetPath(
     claim,
-    mapping_definition,
+    type_definition,
     document_entity_keys,
     document_node_references,
     document_paths,
@@ -59,49 +56,41 @@ export function createPathExistenceDiagnostics(
 /**
  * @param {PatramClaim} claim
  * @param {string} directive_name
- * @param {Record<string, MappingDefinition>} mappings
- * @param {PatramRepoConfig} repo_config
- * @param {Exclude<DirectiveTypeConfig, { type: 'enum' }>} type_definition
+ * @param {Extract<MetadataFieldConfig, { type: 'ref' }>} type_definition
  * @param {Map<string, string>} document_entity_keys
  * @param {Map<string, import('./document-node-identity.js').DocumentNodeReference>} document_node_references
  * @param {Set<string>} document_paths
  * @returns {PatramDiagnostic[]}
  */
-export function createPathClassDiagnostics(
+export function createTargetTypeDiagnostics(
   claim,
   directive_name,
-  mappings,
-  repo_config,
   type_definition,
   document_entity_keys,
   document_node_references,
   document_paths,
 ) {
-  if (type_definition.type !== 'path' || !type_definition.path_class) {
+  if (typeof claim.value !== 'string' || !isPathLikeTarget(claim.value)) {
     return [];
   }
 
-  const path_class_definition =
-    repo_config.path_classes?.[type_definition.path_class];
-
-  if (!path_class_definition) {
-    return [];
-  }
-
-  const mapping_definition = resolveDirectiveMapping(mappings, claim);
   const resolved_target = resolveDirectiveTargetPath(
     claim,
-    mapping_definition,
+    type_definition,
     document_entity_keys,
     document_node_references,
     document_paths,
   );
 
+  if (!resolved_target || !document_paths.has(resolved_target)) {
+    return [];
+  }
+
+  const target_reference = document_node_references.get(resolved_target);
+
   if (
-    !resolved_target ||
-    path_class_definition.prefixes.some((prefix) =>
-      resolved_target.startsWith(prefix),
-    )
+    type_definition.to === 'document' ||
+    target_reference?.class_name === type_definition.to
   ) {
     return [];
   }
@@ -109,15 +98,15 @@ export function createPathClassDiagnostics(
   return [
     createOriginDiagnostic(
       claim,
-      'directive.invalid_path_class',
-      `Directive "${directive_name}" must point to path class "${type_definition.path_class}".`,
+      'directive.invalid_target_type',
+      `Directive "${directive_name}" must point to type "${type_definition.to}".`,
     ),
   ];
 }
 
 /**
  * @param {PatramClaim} claim
- * @param {MappingDefinition | null} mapping_definition
+ * @param {MetadataFieldConfig | undefined} type_definition
  * @param {Map<string, string>} document_entity_keys
  * @param {Map<string, import('./document-node-identity.js').DocumentNodeReference>} document_node_references
  * @param {Set<string>} document_paths
@@ -125,14 +114,15 @@ export function createPathClassDiagnostics(
  */
 function resolveDirectiveTargetPath(
   claim,
-  mapping_definition,
+  type_definition,
   document_entity_keys,
   document_node_references,
   document_paths,
 ) {
-  const target_kind = mapping_definition?.emit?.target_class ?? 'document';
+  const target_type =
+    type_definition?.type === 'ref' ? type_definition.to : 'document';
   const resolved_target = resolveTargetReference(
-    target_kind,
+    target_type,
     'path',
     claim,
     document_entity_keys,
@@ -144,30 +134,9 @@ function resolveDirectiveTargetPath(
 }
 
 /**
- * @param {Record<string, MappingDefinition>} mappings
- * @param {PatramClaim} claim
- * @returns {MappingDefinition | null}
- */
-function resolveDirectiveMapping(mappings, claim) {
-  if (!claim.name || !claim.parser) {
-    return null;
-  }
-
-  return mappings[`${claim.parser}.directive.${claim.name}`] ?? null;
-}
-
-/**
- * @param {MappingDefinition | null} mapping_definition
- * @param {Exclude<DirectiveTypeConfig, { type: 'enum' }> | undefined} type_definition
+ * @param {MetadataFieldConfig | undefined} type_definition
  * @returns {boolean}
  */
-function shouldCheckDirectivePathExistence(
-  mapping_definition,
-  type_definition,
-) {
-  if (type_definition?.type === 'path') {
-    return true;
-  }
-
-  return mapping_definition?.emit?.target === 'path';
+function shouldCheckDirectivePathExistence(type_definition) {
+  return type_definition?.type === 'path' || type_definition?.type === 'ref';
 }

package/lib/graph/check-directive-value.d.ts

@@ -3,17 +3,13 @@
  *
  * @param {PatramClaim} claim
  * @param {string} directive_name
- * @param {Record<string, MappingDefinition>} mappings
  * @param {PatramRepoConfig} repo_config
- * @param {MetadataDirectiveRuleConfig | undefined} _directive_rule
  * @param {Map<string, string>} document_entity_keys
  * @param {Map<string, import('./document-node-identity.js').DocumentNodeReference>} document_node_references
  * @param {Set<string>} document_paths
  * @returns {PatramDiagnostic[]}
  */
-export function checkDirectiveValue(claim: PatramClaim, directive_name: string, mappings: Record<string, MappingDefinition>, repo_config: PatramRepoConfig, _directive_rule: MetadataDirectiveRuleConfig | undefined, document_entity_keys: Map<string, string>, document_node_references: Map<string, import("./document-node-identity.js").DocumentNodeReference>, document_paths: Set<string>): PatramDiagnostic[];
+export function checkDirectiveValue(claim: PatramClaim, directive_name: string, repo_config: PatramRepoConfig, document_entity_keys: Map<string, string>, document_node_references: Map<string, import("./document-node-identity.js").DocumentNodeReference>, document_paths: Set<string>): PatramDiagnostic[];
 import type { PatramClaim } from '../parse/parse-claims.types.d.ts';
-import type { MappingDefinition } from '../config/patram-config.types.d.ts';
 import type { PatramRepoConfig } from '../config/load-patram-config.types.d.ts';
-import type { MetadataDirectiveRuleConfig } from '../config/load-patram-config.types.d.ts';
 import type { PatramDiagnostic } from '../config/load-patram-config.types.d.ts';

package/lib/graph/check-directive-value.js

@@ -1,12 +1,11 @@
 /**
- * @import { DirectiveTypeConfig, MetadataDirectiveRuleConfig, PatramDiagnostic, PatramRepoConfig } from '../config/load-patram-config.types.ts';
+ * @import { MetadataFieldConfig, PatramDiagnostic, PatramRepoConfig } from '../config/load-patram-config.types.ts';
  * @import { PatramClaim } from '../parse/parse-claims.types.ts';
- * @import { MappingDefinition } from '../config/patram-config.types.ts';
  */
 
 import {
-  createPathClassDiagnostics,
   createPathExistenceDiagnostics,
+  createTargetTypeDiagnostics,
 } from './check-directive-path-target.js';
 import { createOriginDiagnostic } from './directive-diagnostics.js';
 import {
@@ -20,9 +19,7 @@ import {
  *
  * @param {PatramClaim} claim
  * @param {string} directive_name
- * @param {Record<string, MappingDefinition>} mappings
  * @param {PatramRepoConfig} repo_config
- * @param {MetadataDirectiveRuleConfig | undefined} _directive_rule
  * @param {Map<string, string>} document_entity_keys
  * @param {Map<string, import('./document-node-identity.js').DocumentNodeReference>} document_node_references
  * @param {Set<string>} document_paths
@@ -31,106 +28,38 @@ import {
 export function checkDirectiveValue(
   claim,
   directive_name,
-  mappings,
   repo_config,
-  _directive_rule,
   document_entity_keys,
   document_node_references,
   document_paths,
 ) {
-  const mapping_definition = resolveDirectiveMapping(mappings, claim);
-  const validation_field_name = getDirectiveValidationFieldName(
-    directive_name,
-    mapping_definition,
-  );
-  if (!validation_field_name || typeof claim.value !== 'string') {
+  if (!directive_name || typeof claim.value !== 'string') {
     return [];
   }
-  const directive_value = claim.value;
-  if (validation_field_name === '$class') {
-    return checkClassValue(claim, directive_name, directive_value, repo_config);
-  }
-  const type_definition = repo_config.fields?.[validation_field_name];
-  if (isStructuralDirectiveField(validation_field_name) || !type_definition) {
-    return collectUntypedPathDiagnostics(
-      claim,
-      directive_name,
-      mapping_definition,
-      document_entity_keys,
-      document_node_references,
-      document_paths,
-    );
-  }
-  return checkTypedDirectiveValue(
-    claim,
-    directive_name,
-    directive_value,
-    mappings,
-    repo_config,
-    mapping_definition,
-    type_definition,
-    document_entity_keys,
-    document_node_references,
-    document_paths,
-  );
-}
 
-/**
- * @param {PatramClaim} claim
- * @param {string} directive_name
- * @param {string} class_name
- * @param {PatramRepoConfig} repo_config
- * @returns {PatramDiagnostic[]}
- */
-function checkClassValue(claim, directive_name, class_name, repo_config) {
-  if (repo_config.classes?.[class_name] !== undefined) {
+  if (directive_name === 'title' || directive_name === 'description') {
     return [];
   }
 
-  return [
-    createOriginDiagnostic(
-      claim,
-      'directive.invalid_enum',
-      `Directive "${directive_name}" must reference a configured class.`,
-    ),
-  ];
-}
+  const type_definition = repo_config.fields?.[directive_name];
+
+  if (!type_definition) {
+    return [];
+  }
 
-/**
- * @param {PatramClaim} claim
- * @param {string} directive_name
- * @param {string} directive_value
- * @param {Record<string, MappingDefinition>} mappings
- * @param {PatramRepoConfig} repo_config
- * @param {MappingDefinition | null} mapping_definition
- * @param {DirectiveTypeConfig} type_definition
- * @param {Map<string, string>} document_entity_keys
- * @param {Map<string, import('./document-node-identity.js').DocumentNodeReference>} document_node_references
- * @param {Set<string>} document_paths
- * @returns {PatramDiagnostic[]}
- */
-function checkTypedDirectiveValue(
-  claim,
-  directive_name,
-  directive_value,
-  mappings,
-  repo_config,
-  mapping_definition,
-  type_definition,
-  document_entity_keys,
-  document_node_references,
-  document_paths,
-) {
   if (type_definition.type === 'enum') {
     return checkEnumValue(
       claim,
       directive_name,
-      directive_value,
+      claim.value,
       type_definition.values,
     );
   }
 
-  if (!isDirectiveValueValid(type_definition, directive_value)) {
+  if (
+    type_definition.type !== 'ref' &&
+    !isDirectiveValueValid(type_definition, claim.value)
+  ) {
     return [
       createOriginDiagnostic(
         claim,
@@ -143,9 +72,6 @@ function checkTypedDirectiveValue(
   return collectPathDiagnostics(
     claim,
     directive_name,
-    mappings,
-    repo_config,
-    mapping_definition,
     type_definition,
     document_entity_keys,
     document_node_references,
@@ -156,38 +82,33 @@ function checkTypedDirectiveValue(
 /**
  * @param {PatramClaim} claim
  * @param {string} directive_name
- * @param {MappingDefinition | null} mapping_definition
- * @param {Map<string, string>} document_entity_keys
- * @param {Map<string, import('./document-node-identity.js').DocumentNodeReference>} document_node_references
- * @param {Set<string>} document_paths
+ * @param {string} directive_value
+ * @param {string[]} allowed_values
  * @returns {PatramDiagnostic[]}
  */
-function collectUntypedPathDiagnostics(
+function checkEnumValue(
   claim,
   directive_name,
-  mapping_definition,
-  document_entity_keys,
-  document_node_references,
-  document_paths,
+  directive_value,
+  allowed_values,
 ) {
-  return createPathExistenceDiagnostics(
-    claim,
-    directive_name,
-    mapping_definition,
-    undefined,
-    document_entity_keys,
-    document_node_references,
-    document_paths,
-  );
+  if (allowed_values.includes(directive_value)) {
+    return [];
+  }
+
+  return [
+    createOriginDiagnostic(
+      claim,
+      'directive.invalid_enum',
+      `Directive "${directive_name}" must be one of ${formatQuotedList(allowed_values)}.`,
+    ),
+  ];
 }
 
 /**
  * @param {PatramClaim} claim
  * @param {string} directive_name
- * @param {Record<string, MappingDefinition>} mappings
- * @param {PatramRepoConfig} repo_config
- * @param {MappingDefinition | null} mapping_definition
- * @param {Exclude<DirectiveTypeConfig, { type: 'enum' }>} type_definition
+ * @param {MetadataFieldConfig} type_definition
  * @param {Map<string, string>} document_entity_keys
  * @param {Map<string, import('./document-node-identity.js').DocumentNodeReference>} document_node_references
  * @param {Set<string>} document_paths
@@ -196,28 +117,28 @@ function collectUntypedPathDiagnostics(
 function collectPathDiagnostics(
   claim,
   directive_name,
-  mappings,
-  repo_config,
-  mapping_definition,
   type_definition,
   document_entity_keys,
   document_node_references,
   document_paths,
 ) {
-  return createPathClassDiagnostics(
+  const diagnostics = createPathExistenceDiagnostics(
     claim,
     directive_name,
-    mappings,
-    repo_config,
     type_definition,
     document_entity_keys,
     document_node_references,
     document_paths,
-  ).concat(
-    createPathExistenceDiagnostics(
+  );
+
+  if (type_definition.type !== 'ref') {
+    return diagnostics;
+  }
+
+  return diagnostics.concat(
+    createTargetTypeDiagnostics(
       claim,
       directive_name,
-      mapping_definition,
       type_definition,
       document_entity_keys,
       document_node_references,
@@ -225,64 +146,3 @@ function collectPathDiagnostics(
     ),
   );
 }
-
-/**
- * @param {PatramClaim} claim
- * @param {string} directive_name
- * @param {string} directive_value
- * @param {string[]} allowed_values
- * @returns {PatramDiagnostic[]}
- */
-function checkEnumValue(
-  claim,
-  directive_name,
-  directive_value,
-  allowed_values,
-) {
-  if (allowed_values.includes(directive_value)) {
-    return [];
-  }
-
-  return [
-    createOriginDiagnostic(
-      claim,
-      'directive.invalid_enum',
-      `Directive "${directive_name}" must be one of ${formatQuotedList(allowed_values)}.`,
-    ),
-  ];
-}
-
-/**
- * @param {Record<string, MappingDefinition>} mappings
- * @param {PatramClaim} claim
- * @returns {MappingDefinition | null}
- */
-function resolveDirectiveMapping(mappings, claim) {
-  if (!claim.name || !claim.parser) {
-    return null;
-  }
-
-  return mappings[`${claim.parser}.directive.${claim.name}`] ?? null;
-}
-
-/**
- * @param {string} directive_name
- * @param {MappingDefinition | null} mapping_definition
- * @returns {string}
- */
-function getDirectiveValidationFieldName(directive_name, mapping_definition) {
-  return mapping_definition?.node?.field ?? directive_name;
-}
-
-/**
- * @param {string} field_name
- * @returns {boolean}
- */
-function isStructuralDirectiveField(field_name) {
-  return (
-    field_name === '$class' ||
-    field_name === '$id' ||
-    field_name === '$path' ||
-    field_name === 'title'
-  );
-}

package/lib/graph/check-graph.d.ts

@@ -4,11 +4,11 @@
  * Reports broken document links and missing edge nodes after graph
  * materialization.
  *
- * Kind: graph
- * Status: active
- * Tracked in: ../../docs/plans/v0/source-anchor-dogfooding.md
- * Decided by: ../../docs/decisions/check-link-target-existence.md
- * Implements: ../../docs/tasks/v0/check-command.md
+ * kind: graph
+ * status: active
+ * tracked_in: ../../docs/plans/v0/source-anchor-dogfooding.md
+ * decided_by: ../../docs/decisions/check-link-target-existence.md
+ * implements: ../../docs/tasks/v0/check-command.md
  * @see {@link ../../docs/decisions/check-link-target-existence.md}
  * @patram
  * @see {@link ./build-graph.js}

package/lib/graph/check-graph.js

@@ -4,6 +4,8 @@
  * @import { PatramClaim } from '../parse/parse-claims.types.ts';
  */
 
+import { getGraphNodePath } from './graph-node.js';
+
 import { checkDirectiveMetadata } from './check-directive-metadata.js';
 
 /**
@@ -12,11 +14,11 @@ import { checkDirectiveMetadata } from './check-directive-metadata.js';
  * Reports broken document links and missing edge nodes after graph
  * materialization.
  *
- * Kind: graph
- * Status: active
- * Tracked in: ../../docs/plans/v0/source-anchor-dogfooding.md
- * Decided by: ../../docs/decisions/check-link-target-existence.md
- * Implements: ../../docs/tasks/v0/check-command.md
+ * kind: graph
+ * status: active
+ * tracked_in: ../../docs/plans/v0/source-anchor-dogfooding.md
+ * decided_by: ../../docs/decisions/check-link-target-existence.md
+ * implements: ../../docs/tasks/v0/check-command.md
  * @see {@link ../../docs/decisions/check-link-target-existence.md}
  * @patram
  * @see {@link ./build-graph.js}
@@ -118,7 +120,7 @@ function collectBrokenLinkDiagnostics(
   target_node,
   existing_file_path_set,
 ) {
-  const target_path = target_node.$path ?? target_node.path;
+  const target_path = getGraphNodePath(target_node);
 
   if (graph_edge.relation !== 'links_to') {
     return;

package/lib/graph/document-node-identity.d.ts

@@ -9,27 +9,27 @@
 /**
  * Collect semantic entity keys defined by canonical documents.
  *
- * @param {Record<string, MappingDefinition>} mappings
+ * @param {PatramConfig} patram_config
  * @param {PatramClaim[]} claims
  * @returns {Map<string, string>}
  */
-export function collectDocumentEntityKeys(mappings: Record<string, MappingDefinition>, claims: PatramClaim[]): Map<string, string>;
+export function collectDocumentEntityKeys(patram_config: PatramConfig, claims: PatramClaim[]): Map<string, string>;
 /**
  * Collect canonical graph identities for document-backed source paths.
  *
- * @param {Record<string, MappingDefinition>} mappings
+ * @param {PatramConfig} patram_config
  * @param {PatramClaim[]} claims
  * @returns {Map<string, DocumentNodeReference>}
  */
-export function collectDocumentNodeReferences(mappings: Record<string, MappingDefinition>, claims: PatramClaim[]): Map<string, DocumentNodeReference>;
+export function collectDocumentNodeReferences(patram_config: PatramConfig, claims: PatramClaim[]): Map<string, DocumentNodeReference>;
 /**
  * Resolve the canonical node id for a source document path.
  *
- * @param {Record<string, string> | undefined} document_node_ids
+ * @param {Record<string, string> | undefined} document_path_ids
  * @param {string} document_path
  * @returns {string}
  */
-export function resolveDocumentNodeId(document_node_ids: Record<string, string> | undefined, document_path: string): string;
+export function resolveDocumentNodeId(document_path_ids: Record<string, string> | undefined, document_path: string): string;
 /**
  * Normalize one repo-relative source path.
  *
@@ -37,11 +37,27 @@ export function resolveDocumentNodeId(document_node_ids: Record<string, string>
  * @returns {string}
  */
 export function normalizeRepoRelativePath(source_path: string): string;
+/**
+ * Resolve one edge target key and canonical path.
+ *
+ * @param {string} target_class
+ * @param {'path' | 'value'} target_type
+ * @param {PatramClaim} claim
+ * @param {Map<string, string>} document_entity_keys
+ * @param {Map<string, DocumentNodeReference>} document_node_references
+ * @param {Set<string>} document_paths
+ * @returns {{ class_name: string, key: string, path?: string }}
+ */
+export function resolveTargetReference(target_class: string, target_type: "path" | "value", claim: PatramClaim, document_entity_keys: Map<string, string>, document_node_references: Map<string, DocumentNodeReference>, document_paths: Set<string>): {
+    class_name: string;
+    key: string;
+    path?: string;
+};
 export type DocumentNodeReference = {
     class_name: string;
     id: string;
     key: string;
     path: string;
 };
-import type { MappingDefinition } from '../config/patram-config.types.d.ts';
+import type { PatramConfig } from '../config/patram-config.types.d.ts';
 import type { PatramClaim } from '../parse/parse-claims.types.d.ts';