@likec4/leanix-bridge 1.53.0

package/dist/index.d.mts

@@ -0,0 +1,559 @@
+//#region src/contracts.d.ts
+/**
+ * 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.
+ */
+/** Single source of truth: must match package.json version. */
+declare const BRIDGE_VERSION: string;
+/** Semantic anchor: LikeC4 FQN (e.g. cloud.backend.api) */
+type CanonicalId = string;
+/** Provider-scoped external identifier (e.g. LeanIX factSheetId) */
+type ExternalId = string;
+/** LikeC4 view id (e.g. index, saas, landscape.overview) */
+type ViewId = string;
+/** LikeC4 relation id; for composite key use sourceFqn|targetFqn|relationId */
+type RelationId = string;
+/** Version of the manifest schema */
+type ManifestVersion = string;
+/** ISO timestamp when the artifact was generated */
+type GeneratedAt = string;
+/** Version of the bridge that produced the artifact */
+type BridgeVersion = string;
+/** Name or id of the mapping profile used */
+type MappingProfile = string;
+/** Provider name (e.g. leanix, drawio) */
+type Provider = string;
+/** External IDs for a single provider (e.g. factSheetId, externalId). */
+interface ProviderExternalIds {
+  factSheetId?: string;
+  externalId?: string;
+  [key: string]: string | undefined;
+}
+/** Entity entry in the manifest: canonical id + optional external IDs per provider. */
+interface ManifestEntity {
+  canonicalId: CanonicalId;
+  external?: Partial<Record<Provider, ProviderExternalIds>>;
+}
+/** View entry in the manifest (viewId + optional provider external ids). */
+interface ManifestView {
+  viewId: ViewId;
+  external?: Partial<Record<Provider, Record<string, string>>>;
+}
+/** Relation entry: composite key and optional external relation id per provider. */
+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 */
+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). */
+declare const BRIDGE_MANIFEST_VERSION = "1.0";
+/** Provider identifier for LeanIX (single source of truth for external.leanix). */
+declare const LEANIX_PROVIDER: "leanix";
+//#endregion
+//#region src/mapping.d.ts
+/**
+ * Configurable LeanIX mapping: LikeC4 kinds/relations/tags → LeanIX fact sheet types and fields.
+ * No universal taxonomy; safe defaults. Actor kind maps to 'Provider' unless overridden.
+ */
+/** Configurable mapping from LikeC4 kinds/relations/tags to LeanIX fact sheet and relation types. */
+interface LeanixMappingConfig {
+  /** LikeC4 element kind → LeanIX fact sheet type */
+  factSheetTypes?: Record<string, string>;
+  /** LikeC4 relationship kind → LeanIX relation type name */
+  relationTypes?: Record<string, string>;
+  /** LikeC4 tags / metadata keys → LeanIX field names (optional) */
+  metadataToFields?: Record<string, string>;
+}
+/** Fallback when element kind is unknown (G25: named constant). */
+declare const FALLBACK_FACT_SHEET_TYPE = "Application";
+/** Fallback when relation kind is unknown (G25: named constant). */
+declare const FALLBACK_RELATION_TYPE = "depends on";
+/** Default mapping: actor → Provider; override factSheetTypes/relationTypes as needed */
+declare const DEFAULT_LEANIX_MAPPING: Required<LeanixMappingConfig>;
+/**
+ * Merges partial mapping config with DEFAULT_LEANIX_MAPPING; returns a full Required<LeanixMappingConfig>.
+ */
+declare function mergeWithDefault(partial?: LeanixMappingConfig | null): Required<LeanixMappingConfig>;
+/**
+ * Returns LeanIX fact sheet type for a LikeC4 element kind.
+ * Uses mapping.factSheetTypes[kind], then 'default', then FALLBACK_FACT_SHEET_TYPE.
+ */
+declare function getFactSheetType(likec4Kind: string, mapping: Required<LeanixMappingConfig>): string;
+/**
+ * Returns LeanIX relation type for a LikeC4 relationship kind.
+ * Uses mapping.relationTypes[kind], then 'default', then FALLBACK_RELATION_TYPE.
+ */
+declare function getRelationType(likec4Kind: string | null, mapping: Required<LeanixMappingConfig>): string;
+//#endregion
+//#region src/model-input.d.ts
+/**
+ * Minimal model shape required by the bridge. Satisfied by LikeC4Model (layouted).
+ * Keeps the bridge decoupled from concrete model class.
+ */
+/** Element shape required by the bridge (id, kind, title, tags, getMetadata). */
+interface BridgeElementLike {
+  id: string;
+  kind: string;
+  title: string;
+  tags: readonly string[];
+  technology?: string | null;
+  getMetadata(): Record<string, unknown>;
+}
+/** Relation shape required by the bridge (id, source, target, kind, title). */
+interface BridgeRelationLike {
+  id: string;
+  source: {
+    id: string;
+  };
+  target: {
+    id: string;
+  };
+  kind: string | null;
+  title?: string | null;
+}
+/** View shape required by the bridge (id only). */
+interface BridgeViewLike {
+  id: string;
+}
+/** Model input for toBridgeManifest / toLeanixInventoryDryRun */
+interface BridgeModelInput {
+  projectId: string;
+  elements(): Iterable<BridgeElementLike>;
+  relationships(): Iterable<BridgeRelationLike>;
+  views(): Iterable<BridgeViewLike>;
+}
+//#endregion
+//#region src/to-bridge-manifest.d.ts
+interface ToBridgeManifestOptions {
+  manifestVersion?: string;
+  generatedAt?: string;
+  bridgeVersion?: string;
+  mappingProfile?: string;
+}
+/**
+ * Produces the identity manifest from a LikeC4 model (canonical IDs + placeholders for external IDs).
+ * Pure function; no live API calls.
+ */
+declare function toBridgeManifest(model: BridgeModelInput, options?: ToBridgeManifestOptions): BridgeManifest;
+//#endregion
+//#region src/to-leanix-inventory-dry-run.d.ts
+/** Single LeanIX fact sheet in dry-run shape (no IDs from live API) */
+interface LeanixFactSheetDryRun {
+  type: string;
+  likec4Id: string;
+  name: string;
+  description?: string;
+  technology?: string;
+  tags?: string[];
+  metadata?: Record<string, unknown>;
+}
+/** Single LeanIX relation in dry-run shape */
+interface LeanixRelationDryRun {
+  type: string;
+  likec4RelationId: string;
+  sourceLikec4Id: string;
+  targetLikec4Id: string;
+  title?: string;
+}
+/** Dry-run inventory: fact sheets and relations as would be sent to LeanIX, without live IDs */
+interface LeanixInventoryDryRun {
+  generatedAt: string;
+  projectId: string;
+  mappingProfile: string;
+  factSheets: LeanixFactSheetDryRun[];
+  relations: LeanixRelationDryRun[];
+}
+/** Options for toLeanixInventoryDryRun (mapping, mappingProfile, generatedAt). */
+interface ToLeanixInventoryDryRunOptions {
+  mapping?: LeanixMappingConfig | null;
+  mappingProfile?: string;
+  generatedAt?: string;
+}
+/**
+ * Produces LeanIX-shaped inventory artifacts (fact sheets + relations) from a LikeC4 model.
+ * Pure function; no live API. Use for dry-run and planning.
+ */
+declare function toLeanixInventoryDryRun(model: BridgeModelInput, options?: ToLeanixInventoryDryRunOptions): LeanixInventoryDryRun;
+//#endregion
+//#region src/report.d.ts
+/** Summary report for the bridge run (no live sync) */
+interface BridgeReport {
+  generatedAt: string;
+  projectId: string;
+  manifestVersion: string;
+  bridgeVersion: string;
+  mappingProfile: string;
+  counts: {
+    entities: number;
+    views: number;
+    relations: number;
+    factSheets: number;
+    leanixRelations: number;
+  };
+  artifacts: {
+    manifest: string;
+    leanixDryRun: string;
+  };
+}
+/**
+ * Builds a summary report (counts, artifact names) from manifest and dry-run. Throws if projectId or mappingProfile differ.
+ */
+declare function buildBridgeReport(manifest: BridgeManifest, leanixDryRun: LeanixInventoryDryRun): BridgeReport;
+//#endregion
+//#region src/leanix-api-client.d.ts
+/**
+ * Low-level LeanIX GraphQL API client.
+ * Handles authentication (Bearer token), request throttling, and errors.
+ */
+/** Configuration for LeanixApiClient (apiToken, baseUrl, requestDelayMs). */
+interface LeanixApiClientConfig {
+  /** LeanIX API token (required for auth). */
+  apiToken: string;
+  /**
+   * Base URL for the LeanIX API (e.g. https://app.leanix.net or https://<workspace>.leanix.net).
+   * Default: https://app.leanix.net
+   */
+  baseUrl?: string;
+  /**
+   * Delay in ms between consecutive GraphQL requests (rate limiting).
+   * Default: 200
+   */
+  requestDelayMs?: number;
+}
+/** Result of a GraphQL request (data or errors). */
+interface GraphQLResponse<T = unknown> {
+  data?: T;
+  errors?: Array<{
+    message: string;
+    path?: string[];
+    extensions?: Record<string, unknown>;
+  }>;
+}
+/** Thrown when the LeanIX API returns errors or non-OK HTTP. */
+declare class LeanixApiError extends Error {
+  readonly statusCode?: number | undefined;
+  readonly graphqlErrors?: GraphQLResponse['errors'];
+  constructor(message: string, statusCode?: number | undefined, graphqlErrors?: GraphQLResponse['errors']);
+}
+/**
+ * LeanIX GraphQL API client with Bearer auth and optional rate limiting.
+ * Throttle state is per instance so multiple clients do not share delay.
+ */
+declare class LeanixApiClient {
+  private readonly baseUrl;
+  private readonly apiToken;
+  private readonly requestDelayMs;
+  /** Last request timestamp for throttling (per instance). */
+  private lastRequestTime;
+  /** Serializes rate-limit and request so only one caller runs at a time. */
+  private rateLimitLock;
+  constructor(config: LeanixApiClientConfig);
+  /**
+   * Execute a GraphQL operation (query or mutation).
+   * Throttles requests by requestDelayMs. Throws LeanixApiError on HTTP or GraphQL errors.
+   */
+  graphql<T = unknown>(query: string, variables?: Record<string, unknown>): Promise<T>;
+}
+//#endregion
+//#region src/sync-to-leanix.d.ts
+/** Options for live sync (idempotent lookup, optional likec4Id custom attribute). */
+interface SyncToLeanixOptions {
+  /** If true, only create fact sheets that do not exist (by name+type). Default: true. */
+  idempotent?: boolean;
+  /** Custom attribute key in LeanIX to store likec4Id for lookup. If not set, lookup by name+type. */
+  likec4IdAttribute?: string;
+}
+/** Result of syncToLeanix (updated manifest, counts, errors). */
+interface SyncToLeanixResult {
+  /** Updated manifest with external.leanix.factSheetId and relation IDs filled. */
+  manifest: BridgeManifest;
+  /** Count of fact sheets created. */
+  factSheetsCreated: number;
+  /** Count of fact sheets reused (when idempotent and found; no mutation). */
+  factSheetsReused: number;
+  /** Count of relations created. */
+  relationsCreated: number;
+  /** Errors encountered (e.g. rate limit, validation). Partial sync may still have updated manifest. */
+  errors: string[];
+}
+/** Single fact sheet entry in a sync plan: what would happen when syncing. */
+interface SyncPlanFactSheetEntry {
+  likec4Id: string;
+  name: string;
+  type: string;
+  /** 'create' = not found in LeanIX; 'update' = found by name+type (idempotent). */
+  action: 'create' | 'update';
+  /** Set when action is 'update': existing LeanIX fact sheet id. */
+  existingFactSheetId?: string;
+}
+/** Single relation entry in a sync plan (relations are always created when source/target exist). */
+interface SyncPlanRelationEntry {
+  likec4RelationId: string;
+  sourceLikec4Id: string;
+  targetLikec4Id: string;
+  type: string;
+  action: 'create';
+}
+/** Summary counts for a sync plan. */
+interface SyncPlanSummary {
+  factSheetsToCreate: number;
+  factSheetsToUpdate: number;
+  relationsToCreate: number;
+}
+/** Sync plan artifact: what would be created/updated in LeanIX (no writes; uses API only to read existing). */
+interface SyncPlan {
+  generatedAt: string;
+  projectId: string;
+  mappingProfile: string;
+  summary: SyncPlanSummary;
+  factSheetPlans: SyncPlanFactSheetEntry[];
+  relationPlans: SyncPlanRelationEntry[];
+  /** Errors from read-only queries (e.g. auth, rate limit). Plan may be partial. */
+  errors: string[];
+}
+/** Options for planSyncToLeanix (idempotent, likec4Id attribute, generatedAt). */
+interface PlanSyncToLeanixOptions {
+  /** If true, plan assumes idempotent sync (look up by likec4IdAttribute or name+type to decide create vs update). Default: true. */
+  idempotent?: boolean;
+  /** Custom attribute key for likec4Id lookup; when set, plan uses it for idempotent resolution. */
+  likec4IdAttribute?: string;
+  /** ISO timestamp for the plan. Default: new Date().toISOString() */
+  generatedAt?: string;
+}
+/**
+ * Produces a sync plan by querying LeanIX for existing fact sheets (read-only; no creates/updates).
+ * Use before syncToLeanix to review what would be created vs updated. Phase 2 dry-run sync planning.
+ */
+declare function planSyncToLeanix(leanixDryRun: LeanixInventoryDryRun, client: LeanixApiClient, options?: PlanSyncToLeanixOptions): Promise<SyncPlan>;
+/**
+ * Syncs the dry-run inventory to LeanIX: creates or finds fact sheets, creates relations,
+ * and returns an updated manifest with external LeanIX IDs.
+ */
+declare function syncToLeanix(manifest: BridgeManifest, leanixDryRun: LeanixInventoryDryRun, client: LeanixApiClient, options?: SyncToLeanixOptions): Promise<SyncToLeanixResult>;
+//#endregion
+//#region src/drawio-leanix-roundtrip.d.ts
+/** Mapping from LikeC4 canonical id to LeanIX identity (fact sheet id or externalId for Draw.io cells or export). */
+interface DrawioLeanixMapping {
+  likec4IdToLeanixId: Record<CanonicalId, string>;
+  /** Composite key (sourceFqn|targetFqn|relationId) -> LeanIX relation id. */
+  relationKeyToLeanixRelationId: Record<string, string>;
+}
+/**
+ * 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.
+ */
+declare function manifestToDrawioLeanixMapping(manifest: BridgeManifest): DrawioLeanixMapping;
+//#endregion
+//#region src/leanix-inventory-snapshot.d.ts
+/** Single fact sheet as returned from LeanIX API (read-only snapshot). */
+interface LeanixFactSheetSnapshotItem {
+  id: string;
+  name: string;
+  type: string;
+  /** Set when fetched with likec4IdAttribute and the fact sheet has that custom attribute. */
+  likec4Id?: string;
+}
+/** Single relation as returned from LeanIX API (read-only snapshot). */
+interface LeanixRelationSnapshotItem {
+  id?: string;
+  sourceFactSheetId: string;
+  targetFactSheetId: string;
+  type: string;
+}
+/** Read-only snapshot of LeanIX inventory for reconciliation. */
+interface LeanixInventorySnapshot {
+  generatedAt: string;
+  /** Workspace or project identifier if available from API. */
+  workspaceId?: string;
+  factSheets: LeanixFactSheetSnapshotItem[];
+  relations: LeanixRelationSnapshotItem[];
+}
+/** Options for fetchLeanixInventorySnapshot (likec4Id attribute, maxFactSheets, generatedAt). */
+interface FetchLeanixInventorySnapshotOptions {
+  /** Custom attribute key to read likec4Id from fact sheets (e.g. "likec4Id"). When set, snapshot items get likec4Id when present. */
+  likec4IdAttribute?: string;
+  /** Max fact sheets to fetch (pagination). Default 1000. */
+  maxFactSheets?: number;
+  /** ISO timestamp for snapshot. Default: new Date().toISOString() */
+  generatedAt?: string;
+}
+/**
+ * Fetches a read-only snapshot of the LeanIX inventory (fact sheets, then relations).
+ * Uses cursor-based pagination. Does not modify LeanIX.
+ */
+declare function fetchLeanixInventorySnapshot(client: LeanixApiClient, options?: FetchLeanixInventorySnapshotOptions): Promise<LeanixInventorySnapshot>;
+//#endregion
+//#region src/reconcile.d.ts
+/** A manifest entity matched to a single LeanIX fact sheet. */
+interface MatchedPair {
+  canonicalId: CanonicalId;
+  factSheetId: string;
+  name: string;
+  type: string;
+}
+/** Manifest entity with no matching LeanIX fact sheet. */
+interface UnmatchedInLikec4 {
+  canonicalId: CanonicalId;
+  name?: string | undefined;
+  type?: string | undefined;
+}
+/** LeanIX fact sheet with no matching manifest entity. */
+interface UnmatchedInLeanix {
+  factSheetId: string;
+  name: string;
+  type: string;
+  likec4Id?: string | undefined;
+}
+/** Manifest entity that could match multiple LeanIX fact sheets (e.g. same name+type). */
+interface AmbiguousMatch {
+  canonicalId: CanonicalId;
+  name?: string | undefined;
+  type?: string | undefined;
+  /** Multiple LeanIX fact sheets could match (e.g. same name+type). */
+  candidateFactSheetIds: string[];
+}
+/** Result of reconciling a LeanIX snapshot with the bridge manifest (matched, unmatched, ambiguous). */
+interface ReconciliationResult {
+  generatedAt: string;
+  manifestProjectId: string;
+  snapshotGeneratedAt: string;
+  matched: MatchedPair[];
+  unmatchedInLikec4: UnmatchedInLikec4[];
+  unmatchedInLeanix: UnmatchedInLeanix[];
+  ambiguous: AmbiguousMatch[];
+  summary: {
+    matched: number;
+    unmatchedInLikec4: number;
+    unmatchedInLeanix: number;
+    ambiguous: number;
+  };
+}
+/** Options for reconcileInventoryWithManifest (generatedAt, optional dry-run for name/type resolution). */
+interface ReconcileOptions {
+  generatedAt?: string;
+  /** When provided, name+type matching and ambiguous detection use dry-run fact sheet names/types. */
+  dryRun?: LeanixInventoryDryRun;
+}
+/**
+ * Reconciles a LeanIX inventory snapshot with the bridge manifest.
+ * Matching order: 1) manifest entity has external.leanix.factSheetId; 2) snapshot fact sheet has likec4Id === canonicalId; 3) if dryRun provided, name+type (can be ambiguous).
+ * Does not modify any data; no DSL generation.
+ */
+declare function reconcileInventoryWithManifest(snapshot: LeanixInventorySnapshot, manifest: BridgeManifest, options?: ReconcileOptions): ReconciliationResult;
+//#endregion
+//#region src/impact-report.d.ts
+/** Impact report from a sync plan (summary counts and human-readable impact summary). */
+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.
+ */
+declare function impactReportFromSyncPlan(plan: SyncPlan): ImpactReport;
+//#endregion
+//#region src/drift-report.d.ts
+/** Drift status: in_sync, likec4_ahead, leanix_ahead, or diverged. */
+type DriftStatus = 'in_sync' | 'likec4_ahead' | 'leanix_ahead' | 'diverged';
+/** Drift report (status, summary, description). */
+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.
+ */
+declare function buildDriftReport(reconciliation: ReconciliationResult): DriftReport;
+//#endregion
+//#region src/adr-generation.d.ts
+/** Options for ADR generation (title, status, optional impact report). */
+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.
+ */
+declare function generateAdrFromReconciliation(reconciliation: ReconciliationResult, options?: AdrGenerationOptions): string;
+/** Options for ADR generation from a drift report (subset of AdrGenerationOptions). */
+type DriftAdrGenerationOptions = Pick<AdrGenerationOptions, 'title' | 'status'>;
+/**
+ * Generates a short ADR-style markdown from a drift report.
+ */
+declare function generateAdrFromDriftReport(drift: DriftReport, options?: DriftAdrGenerationOptions): string;
+//#endregion
+//#region src/governance-checks.d.ts
+/** Single governance check result (id, name, passed, optional message). */
+interface GovernanceCheckResult {
+  id: string;
+  name: string;
+  passed: boolean;
+  message?: string;
+}
+interface GovernanceReport {
+  passed: boolean;
+  generatedAt: string;
+  checks: GovernanceCheckResult[];
+}
+/** Options for runGovernanceChecks (noAmbiguous, allLikec4Matched, noOrphanInLeanix). */
+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;
+}
+/**
+ * Runs governance checks on a reconciliation result.
+ * Returns a report with one entry per check; overall passed iff all checks pass.
+ */
+declare function runGovernanceChecks(reconciliation: ReconciliationResult, options?: GovernanceCheckOptions): GovernanceReport;
+//#endregion
+//#region src/validate.d.ts
+/**
+ * Returns true if the value is a valid BridgeManifest shape (manifestVersion, generatedAt, bridgeVersion, mappingProfile, projectId, entities, relations, views)
+ * and nested entities/views/relations match expected shapes.
+ */
+declare function isBridgeManifest(obj: unknown): obj is BridgeManifest;
+/**
+ * Returns true if the value is a valid LeanixInventorySnapshot shape (generatedAt, factSheets and relations arrays)
+ * and each fact sheet/relation item has required fields.
+ */
+declare function isLeanixInventorySnapshot(obj: unknown): obj is LeanixInventorySnapshot;
+//#endregion
+export { type AdrGenerationOptions, type AmbiguousMatch, BRIDGE_MANIFEST_VERSION, BRIDGE_VERSION, type BridgeElementLike, type BridgeManifest, type BridgeModelInput, type RelationId as BridgeRelationId, type BridgeRelationLike, type BridgeReport, type BridgeVersion, type ViewId as BridgeViewId, type BridgeViewLike, type CanonicalId, DEFAULT_LEANIX_MAPPING, type DrawioLeanixMapping, type DriftAdrGenerationOptions, type DriftReport, type DriftStatus, type ExternalId, FALLBACK_FACT_SHEET_TYPE, FALLBACK_RELATION_TYPE, type FetchLeanixInventorySnapshotOptions, type GeneratedAt, type GovernanceCheckOptions, type GovernanceCheckResult, type GovernanceReport, type GraphQLResponse, type ImpactReport, LEANIX_PROVIDER, LeanixApiClient, type LeanixApiClientConfig, LeanixApiError, type LeanixFactSheetDryRun, type LeanixFactSheetSnapshotItem, type LeanixInventoryDryRun, type LeanixInventorySnapshot, type LeanixMappingConfig, type LeanixRelationDryRun, type LeanixRelationSnapshotItem, type ManifestEntity, type ManifestRelation, type ManifestVersion, type ManifestView, type MappingProfile, type MatchedPair, type PlanSyncToLeanixOptions, type Provider, type ProviderExternalIds, type ReconcileOptions, type ReconciliationResult, type SyncPlan, type SyncPlanFactSheetEntry, type SyncPlanRelationEntry, type SyncPlanSummary, type SyncToLeanixOptions, type SyncToLeanixResult, type ToBridgeManifestOptions, type ToLeanixInventoryDryRunOptions, type UnmatchedInLeanix, type UnmatchedInLikec4, buildBridgeReport, buildDriftReport, fetchLeanixInventorySnapshot, generateAdrFromDriftReport, generateAdrFromReconciliation, getFactSheetType, getRelationType, impactReportFromSyncPlan, isBridgeManifest, isLeanixInventorySnapshot, manifestToDrawioLeanixMapping, mergeWithDefault, planSyncToLeanix, reconcileInventoryWithManifest, runGovernanceChecks, syncToLeanix, toBridgeManifest, toLeanixInventoryDryRun };