@likec4/leanix-bridge 1.53.0

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@likec4/leanix-bridge",
+  "version": "1.53.0",
+  "license": "MIT",
+  "bugs": "https://github.com/likec4/likec4/issues",
+  "homepage": "https://likec4.dev",
+  "author": "Denis Davydkov <denis@davydkov.com>",
+  "description": "Bridge from LikeC4 semantic model to LeanIX-shaped inventory artifacts (supports optional live sync or dry-run modes)",
+  "files": [
+    "dist",
+    "src",
+    "**/package.json",
+    "!**/__*/**",
+    "!**/*.spec.*",
+    "!**/*.snap",
+    "!**/*.map"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/likec4/likec4.git",
+    "directory": "packages/leanix-bridge"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "sources": "./src/index.ts",
+      "default": {
+        "types": "./dist/index.d.mts",
+        "import": "./dist/index.mjs",
+        "default": "./dist/index.mjs"
+      }
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "dependencies": {
+    "remeda": "^2.33.6",
+    "@likec4/core": "1.53.0"
+  },
+  "devDependencies": {
+    "@types/node": "~22.19.15",
+    "typescript": "5.9.3",
+    "obuild": "0.4.31",
+    "vitest": "4.1.0",
+    "@likec4/devops": "1.42.0",
+    "@likec4/tsconfig": "1.53.0"
+  },
+  "scripts": {
+    "typecheck": "tsc -b --verbose",
+    "build": "obuild",
+    "lint": "oxlint --type-aware",
+    "clean": "likec4ops clean",
+    "pack": "pnpm pack",
+    "test": "vitest run --no-isolate",
+    "test:watch": "vitest"
+  },
+  "types": "dist/index.d.mts",
+  "module": "dist/index.mjs"
+}

package/src/adr-generation.ts

@@ -0,0 +1,105 @@
+/**
+ * Phase 3: Generate an Architecture Decision Record (ADR) from reconciliation and/or impact.
+ * Output is markdown; no DSL generation.
+ */
+
+import type { DriftReport } from './drift-report'
+import type { ImpactReport } from './impact-report'
+import type { ReconciliationResult } from './reconcile'
+
+/** Returns date part YYYY-MM-DD from ISO timestamp (G25, G5). Handles short strings defensively. */
+function formatIsoDateString(iso: string): string {
+  if (typeof iso !== 'string' || iso.length < 10) return iso
+  return iso.slice(0, 10)
+}
+
+/** Shared ADR header lines (title, status, date). Reduces duplication between ADR generators. */
+function buildAdrHeader(title: string, status: string, dateIso: string): string[] {
+  return [
+    `# ${title}`,
+    '',
+    `- Status: ${status}`,
+    `- Date: ${formatIsoDateString(dateIso)}`,
+    '',
+  ]
+}
+
+/** Options for ADR generation (title, status, optional impact report). */
+export interface AdrGenerationOptions {
+  title?: string
+  /** ADR status line. Default: "Proposed". */
+  status?: string
+  /** Optional impact report to include. */
+  impact?: ImpactReport
+}
+
+/**
+ * Generates a short ADR-style markdown document from a reconciliation result (and optional impact).
+ * Use for governance or audit trail; does not modify any data.
+ */
+export function generateAdrFromReconciliation(
+  reconciliation: ReconciliationResult,
+  options: AdrGenerationOptions = {},
+): string {
+  const title = options.title ?? 'LeanIX inventory reconciliation'
+  const status = options.status ?? 'Proposed'
+  const impact = options.impact
+  const lines: string[] = [
+    ...buildAdrHeader(title, status, reconciliation.generatedAt),
+    '## Context',
+    '',
+    `Reconciliation of LikeC4 manifest (project: ${reconciliation.manifestProjectId}) with LeanIX inventory snapshot (${
+      formatIsoDateString(reconciliation.snapshotGeneratedAt)
+    }).`,
+    '',
+    '## Result',
+    '',
+    `- Matched: ${reconciliation.summary.matched}`,
+    `- Unmatched in LikeC4: ${reconciliation.summary.unmatchedInLikec4}`,
+    `- Unmatched in LeanIX: ${reconciliation.summary.unmatchedInLeanix}`,
+    `- Ambiguous: ${reconciliation.summary.ambiguous}`,
+    '',
+  ]
+  if (impact) {
+    lines.push('## Impact (if sync applied)', '', impact.impactSummary, '', '')
+  }
+  lines.push(
+    '## Decision',
+    '',
+    'LikeC4 remains the single source of truth; LeanIX is an adapter. No DSL is auto-generated from LeanIX.',
+    '',
+  )
+  return lines.join('\n')
+}
+
+/** Options for ADR generation from a drift report (subset of AdrGenerationOptions). */
+export type DriftAdrGenerationOptions = Pick<AdrGenerationOptions, 'title' | 'status'>
+
+/**
+ * Generates a short ADR-style markdown from a drift report.
+ */
+export function generateAdrFromDriftReport(
+  drift: DriftReport,
+  options: DriftAdrGenerationOptions = {},
+): string {
+  const title = options.title ?? 'LeanIX drift report'
+  const status = options.status ?? 'Proposed'
+  return [
+    ...buildAdrHeader(title, status, drift.generatedAt),
+    '## Drift status',
+    '',
+    drift.description,
+    '',
+    '## Summary',
+    '',
+    `- Matched: ${drift.summary.matched}`,
+    `- Unmatched in LikeC4: ${drift.summary.unmatchedInLikec4}`,
+    `- Unmatched in LeanIX: ${drift.summary.unmatchedInLeanix}`,
+    `- Ambiguous: ${drift.summary.ambiguous}`,
+    '',
+    '## Decision',
+    '',
+    'Review drift findings and determine whether synchronization or manual remediation is required.',
+    '',
+  ].join('\n')
+}

package/src/contracts.ts

@@ -0,0 +1,96 @@
+/**
+ * Canonical bridge contracts for LikeC4 ↔ LeanIX interoperability.
+ * LikeC4 remains the semantic source of truth; external IDs are provider-scoped.
+ * Uses readFileSync (not require) so when bundled into likec4 CLI the bundler
+ * does not emit require('../package.json') which fails in the tarball layout.
+ */
+
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const _dir = dirname(fileURLToPath(import.meta.url))
+function readVersion(): string {
+  try {
+    const pkg = JSON.parse(readFileSync(join(_dir, '..', 'package.json'), 'utf8')) as { version?: string }
+    return pkg.version ?? '0.1.0'
+  } catch {
+    const pkg = JSON.parse(readFileSync(join(_dir, '..', '..', 'package.json'), 'utf8')) as { version?: string }
+    return pkg.version ?? '0.1.0'
+  }
+}
+/** Single source of truth: must match package.json version. */
+export const BRIDGE_VERSION: string = readVersion()
+
+/** Semantic anchor: LikeC4 FQN (e.g. cloud.backend.api) */
+export type CanonicalId = string
+
+/** Provider-scoped external identifier (e.g. LeanIX factSheetId) */
+export type ExternalId = string
+
+/** LikeC4 view id (e.g. index, saas, landscape.overview) */
+export type ViewId = string
+
+/** LikeC4 relation id; for composite key use sourceFqn|targetFqn|relationId */
+export type RelationId = string
+
+/** Version of the manifest schema */
+export type ManifestVersion = string
+
+/** ISO timestamp when the artifact was generated */
+export type GeneratedAt = string
+
+/** Version of the bridge that produced the artifact */
+export type BridgeVersion = string
+
+/** Name or id of the mapping profile used */
+export type MappingProfile = string
+
+/** Provider name (e.g. leanix, drawio) */
+export type Provider = string
+
+/** External IDs for a single provider (e.g. factSheetId, externalId). */
+export interface ProviderExternalIds {
+  factSheetId?: string
+  externalId?: string
+  [key: string]: string | undefined
+}
+
+/** Entity entry in the manifest: canonical id + optional external IDs per provider. */
+export interface ManifestEntity {
+  canonicalId: CanonicalId
+  external?: Partial<Record<Provider, ProviderExternalIds>>
+}
+
+/** View entry in the manifest (viewId + optional provider external ids). */
+export interface ManifestView {
+  viewId: ViewId
+  external?: Partial<Record<Provider, Record<string, string>>>
+}
+
+/** Relation entry: composite key and optional external relation id per provider. */
+export interface ManifestRelation {
+  relationId: RelationId
+  sourceFqn: CanonicalId
+  targetFqn: CanonicalId
+  compositeKey: string
+  external?: Partial<Record<Provider, { relationId?: string; [key: string]: string | undefined }>>
+}
+
+/** Identity manifest: canonical IDs and provider-scoped external IDs */
+export interface BridgeManifest {
+  manifestVersion: ManifestVersion
+  generatedAt: GeneratedAt
+  bridgeVersion: BridgeVersion
+  mappingProfile: MappingProfile
+  projectId: string
+  entities: Record<CanonicalId, ManifestEntity>
+  views: Record<ViewId, ManifestView>
+  relations: ManifestRelation[]
+}
+
+/** Manifest schema version (semantic; must match parser). */
+export const BRIDGE_MANIFEST_VERSION = '1.0'
+
+/** Provider identifier for LeanIX (single source of truth for external.leanix). */
+export const LEANIX_PROVIDER = 'leanix' as const

package/src/drawio-leanix-roundtrip.ts

@@ -0,0 +1,51 @@
+/**
+ * Draw.io ↔ LeanIX round-trip: mapping between bridge manifest (with LeanIX external IDs)
+ * and diagram identity (likec4Id, likec4RelationId).
+ * Use after syncToLeanix to get a mapping for re-export or for annotating diagrams.
+ */
+
+import { type BridgeManifest, type CanonicalId, LEANIX_PROVIDER } from './contracts'
+
+/** Mapping from LikeC4 canonical id to LeanIX identity (fact sheet id or externalId for Draw.io cells or export). */
+export interface DrawioLeanixMapping {
+  likec4IdToLeanixId: Record<CanonicalId, string>
+  /** Composite key (sourceFqn|targetFqn|relationId) -> LeanIX relation id. */
+  relationKeyToLeanixRelationId: Record<string, string>
+}
+
+/**
+ * Collects likec4Id → LeanIX identity (factSheetId or externalId) from manifest entities that have LeanIX external.
+ * Single responsibility: one level of abstraction for entity extraction.
+ */
+function collectLikec4IdToLeanixId(manifest: BridgeManifest): Record<CanonicalId, string> {
+  const out: Record<CanonicalId, string> = {}
+  for (const [canonicalId, entity] of Object.entries(manifest.entities)) {
+    const leanixId = entity.external?.[LEANIX_PROVIDER]?.factSheetId ?? entity.external?.[LEANIX_PROVIDER]?.externalId
+    if (leanixId) out[canonicalId] = leanixId
+  }
+  return out
+}
+
+/**
+ * Collects compositeKey → LeanIX relationId from manifest relations that have LeanIX external.
+ * Single responsibility: one level of abstraction for relation extraction.
+ */
+function collectRelationKeyToLeanixRelationId(manifest: BridgeManifest): Record<string, string> {
+  const out: Record<string, string> = {}
+  for (const rel of manifest.relations) {
+    const leanixRelId = rel.external?.[LEANIX_PROVIDER]?.relationId
+    if (leanixRelId) out[rel.compositeKey] = leanixRelId
+  }
+  return out
+}
+
+/**
+ * Builds a mapping from manifest (after sync) for use in Draw.io bridge-managed export
+ * or when re-importing from LeanIX. Elements can store leanixFactSheetId in style for round-trip.
+ */
+export function manifestToDrawioLeanixMapping(manifest: BridgeManifest): DrawioLeanixMapping {
+  return {
+    likec4IdToLeanixId: collectLikec4IdToLeanixId(manifest),
+    relationKeyToLeanixRelationId: collectRelationKeyToLeanixRelationId(manifest),
+  }
+}

package/src/drift-report.ts

@@ -0,0 +1,61 @@
+/**
+ * Phase 3: Drift detection from reconciliation result.
+ * Produces a structured drift report (in sync, LikeC4 ahead, LeanIX ahead, or diverged).
+ */
+
+import type { ReconciliationResult } from './reconcile'
+
+/** Drift status: in_sync, likec4_ahead, leanix_ahead, or diverged. */
+export type DriftStatus = 'in_sync' | 'likec4_ahead' | 'leanix_ahead' | 'diverged'
+
+/** Drift report (status, summary, description). */
+export interface DriftReport {
+  generatedAt: string
+  manifestProjectId: string
+  snapshotGeneratedAt: string
+  status: DriftStatus
+  summary: ReconciliationResult['summary']
+  /** Short human-readable drift description. */
+  description: string
+}
+
+/**
+ * Builds a drift report from a reconciliation result.
+ * In_sync: all matched, no unmatched, no ambiguous. Likec4_ahead: only unmatched in LikeC4. Leanix_ahead: only unmatched in LeanIX. Diverged: mixed or ambiguous.
+ */
+export function buildDriftReport(reconciliation: ReconciliationResult): DriftReport {
+  const { summary } = reconciliation
+  const hasUnmatchedLikec4 = summary.unmatchedInLikec4 > 0
+  const hasUnmatchedLeanix = summary.unmatchedInLeanix > 0
+  const hasAmbiguous = summary.ambiguous > 0
+
+  let status: DriftStatus
+  let description: string
+  switch (true) {
+    case hasAmbiguous || (hasUnmatchedLikec4 && hasUnmatchedLeanix):
+      status = 'diverged'
+      description =
+        `${summary.ambiguous} ambiguous; ${summary.unmatchedInLikec4} only in LikeC4, ${summary.unmatchedInLeanix} only in LeanIX`
+      break
+    case hasUnmatchedLikec4 && !hasUnmatchedLeanix:
+      status = 'likec4_ahead'
+      description = `${summary.unmatchedInLikec4} element(s) in LikeC4 not yet in LeanIX`
+      break
+    case hasUnmatchedLeanix && !hasUnmatchedLikec4:
+      status = 'leanix_ahead'
+      description = `${summary.unmatchedInLeanix} fact sheet(s) in LeanIX not in LikeC4`
+      break
+    default:
+      status = 'in_sync'
+      description = `${summary.matched} matched; no drift`
+  }
+
+  return {
+    generatedAt: reconciliation.generatedAt,
+    manifestProjectId: reconciliation.manifestProjectId,
+    snapshotGeneratedAt: reconciliation.snapshotGeneratedAt,
+    status,
+    summary: reconciliation.summary,
+    description,
+  }
+}

package/src/fixture-model.ts

@@ -0,0 +1,52 @@
+import type { BridgeModelInput } from './model-input'
+
+/** Minimal in-memory model for tests */
+export function createFixtureModel(overrides: Partial<{
+  projectId: string
+  elements: Array<
+    {
+      id: string
+      kind: string
+      title: string
+      tags?: string[]
+      technology?: string | null
+      metadata?: Record<string, unknown>
+    }
+  >
+  relations: Array<{ id: string; source: string; target: string; kind?: string | null; title?: string | null }>
+  views: Array<{ id: string }>
+}> = {}): BridgeModelInput {
+  const projectId = overrides.projectId ?? 'test-project'
+  const elements = overrides.elements ?? [
+    { id: 'cloud', kind: 'system', title: 'Cloud', tags: [], metadata: {} },
+    { id: 'cloud.backend', kind: 'container', title: 'Backend', tags: [], metadata: {} },
+    { id: 'cloud.backend.api', kind: 'component', title: 'API', tags: ['core'], technology: 'Node', metadata: {} },
+  ]
+  const relations = overrides.relations ?? [
+    { id: 'r1', source: 'cloud', target: 'cloud.backend', kind: 'contains', title: null },
+    { id: 'r2', source: 'cloud.backend', target: 'cloud.backend.api', kind: 'contains', title: null },
+  ]
+  const views = overrides.views ?? [{ id: 'index' }, { id: 'landscape' }]
+
+  return {
+    projectId,
+    elements: () =>
+      elements.map(e => ({
+        id: e.id,
+        kind: e.kind,
+        title: e.title,
+        tags: e.tags ?? [],
+        technology: e.technology ?? null,
+        getMetadata: () => e.metadata ?? {},
+      })),
+    relationships: () =>
+      relations.map(r => ({
+        id: r.id,
+        source: { id: r.source },
+        target: { id: r.target },
+        kind: r.kind ?? null,
+        title: r.title ?? null,
+      })),
+    views: () => views.map(v => ({ id: v.id })),
+  }
+}

package/src/governance-checks.ts

@@ -0,0 +1,103 @@
+/**
+ * Phase 3: Governance checks on reconciliation result.
+ * Configurable rules (no ambiguous, all LikeC4 matched, no orphans in LeanIX); returns pass/fail per check.
+ */
+
+import type { ReconciliationResult } from './reconcile'
+
+/** Single governance check result (id, name, passed, optional message). */
+export interface GovernanceCheckResult {
+  id: string
+  name: string
+  passed: boolean
+  message?: string
+}
+
+export interface GovernanceReport {
+  passed: boolean
+  generatedAt: string
+  checks: GovernanceCheckResult[]
+}
+
+/** Options for runGovernanceChecks (noAmbiguous, allLikec4Matched, noOrphanInLeanix). */
+export interface GovernanceCheckOptions {
+  /** Fail if any ambiguous matches. Default: true. */
+  noAmbiguous?: boolean
+  /** Fail if any LikeC4 entity has no match in LeanIX. Default: false. */
+  allLikec4Matched?: boolean
+  /** Fail if any LeanIX fact sheet has no match in LikeC4. Default: false. */
+  noOrphanInLeanix?: boolean
+}
+
+const DEFAULT_OPTIONS: Required<GovernanceCheckOptions> = {
+  noAmbiguous: true,
+  allLikec4Matched: false,
+  noOrphanInLeanix: false,
+}
+
+/** Builds a single check result (G5: reduce duplication). */
+function buildCheck(
+  id: string,
+  name: string,
+  passed: boolean,
+  failedMessage?: string,
+): GovernanceCheckResult {
+  const result: GovernanceCheckResult = { id, name, passed }
+  if (!passed && failedMessage !== undefined) {
+    result.message = failedMessage
+  }
+  return result
+}
+
+/**
+ * Runs governance checks on a reconciliation result.
+ * Returns a report with one entry per check; overall passed iff all checks pass.
+ */
+export function runGovernanceChecks(
+  reconciliation: ReconciliationResult,
+  options: GovernanceCheckOptions = {},
+): GovernanceReport {
+  const opts = { ...DEFAULT_OPTIONS, ...options }
+  const checks: GovernanceCheckResult[] = []
+  const { summary } = reconciliation
+
+  if (opts.noAmbiguous) {
+    checks.push(
+      buildCheck(
+        'noAmbiguous',
+        'No ambiguous matches',
+        summary.ambiguous === 0,
+        `${summary.ambiguous} ambiguous match(es)`,
+      ),
+    )
+  }
+
+  if (opts.allLikec4Matched) {
+    checks.push(
+      buildCheck(
+        'allLikec4Matched',
+        'All LikeC4 elements matched in LeanIX',
+        summary.unmatchedInLikec4 === 0,
+        `${summary.unmatchedInLikec4} unmatched in LikeC4`,
+      ),
+    )
+  }
+
+  if (opts.noOrphanInLeanix) {
+    checks.push(
+      buildCheck(
+        'noOrphanInLeanix',
+        'No LeanIX fact sheets without LikeC4 match',
+        summary.unmatchedInLeanix === 0,
+        `${summary.unmatchedInLeanix} unmatched in LeanIX`,
+      ),
+    )
+  }
+
+  const passed = checks.every(c => c.passed)
+  return {
+    passed,
+    generatedAt: new Date().toISOString(),
+    checks,
+  }
+}

package/src/impact-report.ts

@@ -0,0 +1,38 @@
+/**
+ * Phase 3: Impact analysis from a sync plan.
+ * Produces a structured report of what would change if the plan were applied (no writes).
+ */
+
+import type { SyncPlan, SyncPlanSummary } from './sync-to-leanix'
+
+/** Impact report from a sync plan (summary counts and human-readable impact summary). */
+export interface ImpactReport {
+  generatedAt: string
+  projectId: string
+  mappingProfile: string
+  summary: SyncPlanSummary
+  /** Human-readable one-line impact summary. */
+  impactSummary: string
+  hasErrors: boolean
+}
+
+/**
+ * Builds an impact report from a sync plan (read-only).
+ * Use before applying sync to understand what would be created/updated.
+ */
+export function impactReportFromSyncPlan(plan: SyncPlan): ImpactReport {
+  const { summary, errors } = plan
+  const parts: string[] = []
+  if (summary.factSheetsToCreate > 0) parts.push(`${summary.factSheetsToCreate} fact sheet(s) to create`)
+  if (summary.factSheetsToUpdate > 0) parts.push(`${summary.factSheetsToUpdate} fact sheet(s) to update`)
+  if (summary.relationsToCreate > 0) parts.push(`${summary.relationsToCreate} relation(s) to create`)
+  const impactSummary = parts.length > 0 ? parts.join('; ') : 'No changes'
+  return {
+    generatedAt: plan.generatedAt,
+    projectId: plan.projectId,
+    mappingProfile: plan.mappingProfile,
+    summary,
+    impactSummary: errors.length > 0 ? `${impactSummary} (${errors.length} plan error(s))` : impactSummary,
+    hasErrors: errors.length > 0,
+  }
+}

package/src/index.ts

@@ -0,0 +1,109 @@
+/**
+ * @likec4/leanix-bridge
+ *
+ * Bridge from LikeC4 semantic model to LeanIX-shaped inventory artifacts.
+ * Supports dry-run artifacts, optional LeanIX API sync (LeanixApiClient, syncToLeanix),
+ * and Draw.io round-trip helpers (manifestToDrawioLeanixMapping). LikeC4 remains canonical.
+ */
+
+export {
+  BRIDGE_MANIFEST_VERSION,
+  BRIDGE_VERSION,
+  LEANIX_PROVIDER,
+} from './contracts'
+export type {
+  BridgeManifest,
+  BridgeVersion,
+  CanonicalId,
+  ExternalId,
+  GeneratedAt,
+  ManifestEntity,
+  ManifestRelation,
+  ManifestVersion,
+  ManifestView,
+  MappingProfile,
+  Provider,
+  ProviderExternalIds,
+  RelationId as BridgeRelationId,
+  ViewId as BridgeViewId,
+} from './contracts'
+
+export {
+  DEFAULT_LEANIX_MAPPING,
+  FALLBACK_FACT_SHEET_TYPE,
+  FALLBACK_RELATION_TYPE,
+  getFactSheetType,
+  getRelationType,
+  mergeWithDefault,
+} from './mapping'
+export type { LeanixMappingConfig } from './mapping'
+
+export type { BridgeElementLike, BridgeModelInput, BridgeRelationLike, BridgeViewLike } from './model-input'
+
+export { toBridgeManifest } from './to-bridge-manifest'
+export type { ToBridgeManifestOptions } from './to-bridge-manifest'
+
+export { toLeanixInventoryDryRun } from './to-leanix-inventory-dry-run'
+export type {
+  LeanixFactSheetDryRun,
+  LeanixInventoryDryRun,
+  LeanixRelationDryRun,
+  ToLeanixInventoryDryRunOptions,
+} from './to-leanix-inventory-dry-run'
+
+export { buildBridgeReport } from './report'
+export type { BridgeReport } from './report'
+
+export { LeanixApiClient } from './leanix-api-client'
+export type { GraphQLResponse, LeanixApiClientConfig } from './leanix-api-client'
+export { LeanixApiError } from './leanix-api-client'
+
+export { planSyncToLeanix, syncToLeanix } from './sync-to-leanix'
+export type {
+  PlanSyncToLeanixOptions,
+  SyncPlan,
+  SyncPlanFactSheetEntry,
+  SyncPlanRelationEntry,
+  SyncPlanSummary,
+  SyncToLeanixOptions,
+  SyncToLeanixResult,
+} from './sync-to-leanix'
+
+export { manifestToDrawioLeanixMapping } from './drawio-leanix-roundtrip'
+export type { DrawioLeanixMapping } from './drawio-leanix-roundtrip'
+
+export { fetchLeanixInventorySnapshot } from './leanix-inventory-snapshot'
+export type {
+  FetchLeanixInventorySnapshotOptions,
+  LeanixFactSheetSnapshotItem,
+  LeanixInventorySnapshot,
+  LeanixRelationSnapshotItem,
+} from './leanix-inventory-snapshot'
+
+export { reconcileInventoryWithManifest } from './reconcile'
+export type {
+  AmbiguousMatch,
+  MatchedPair,
+  ReconcileOptions,
+  ReconciliationResult,
+  UnmatchedInLeanix,
+  UnmatchedInLikec4,
+} from './reconcile'
+
+export { impactReportFromSyncPlan } from './impact-report'
+export type { ImpactReport } from './impact-report'
+
+export { buildDriftReport } from './drift-report'
+export type { DriftReport, DriftStatus } from './drift-report'
+
+export { generateAdrFromDriftReport, generateAdrFromReconciliation } from './adr-generation'
+export type { AdrGenerationOptions, DriftAdrGenerationOptions } from './adr-generation'
+
+export { runGovernanceChecks } from './governance-checks'
+export type {
+  GovernanceCheckOptions,
+  GovernanceCheckResult,
+  GovernanceReport,
+} from './governance-checks'
+
+export { isBridgeManifest, isLeanixInventorySnapshot } from './validate'