merslim 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,654 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { RefObject, ComponentType } from 'react';
+
+interface DbColumn {
+    name: string;
+    type: string;
+    isPK: boolean;
+    isFK: boolean;
+    isNullable: boolean;
+    isUnique: boolean;
+}
+interface DbRelation {
+    fromTable: string;
+    fromCol: string;
+    toTable: string;
+    toCol: string;
+    nullable: boolean;
+}
+interface DbTable {
+    name: string;
+    columns: DbColumn[];
+}
+interface ParsedSchema {
+    tables: DbTable[];
+    relations: DbRelation[];
+    inputFormat: 'sql' | 'prisma' | 'dbdiagram' | 'unknown';
+}
+/** Category of node, used for visual styling (color, icon, shape). */
+type NodeKind = 'service' | 'database' | 'queue' | 'storage' | 'user' | 'client' | 'external' | 'process' | 'decision' | 'start' | 'end' | 'icon' | 'plain';
+interface NodeIR {
+    /** Stable id used by edges to refer to this node. */
+    id: string;
+    /** Visible label. May contain markdown-ish bold/italic; renderers decide. */
+    label: string;
+    /** Visual category. Renderer maps this to shape/color/icon. */
+    kind: NodeKind;
+    /** Optional iconify-style ref (e.g. `logos:aws-rds`). When set, renderer
+     *  shows the icon as the primary visual. */
+    icon?: string;
+    /** Optional subgraph this node belongs to. Maps to a cluster/group. */
+    subgraph?: string;
+    /** Free-form metadata for renderer-specific extensions. */
+    meta?: Record<string, unknown>;
+}
+type EdgeKind = 'solid' | 'dashed' | 'thick' | 'dotted' | 'invisible';
+type EdgeArrow = 'none' | 'arrow' | 'open' | 'cross' | 'circle' | 'biarrow';
+interface EdgeIR {
+    /** Source node id. */
+    source: string;
+    /** Target node id. */
+    target: string;
+    /** Optional label rendered along the edge. */
+    label?: string;
+    /** Visual style of the edge. */
+    kind?: EdgeKind;
+    /** Arrow head style on each end. Default: source=none, target=arrow. */
+    arrow?: {
+        source?: EdgeArrow;
+        target?: EdgeArrow;
+    };
+}
+type FlowDirection = 'TB' | 'BT' | 'LR' | 'RL';
+interface SubgraphIR {
+    id: string;
+    label: string;
+    /** Optional nested subgraphs. */
+    subgraphs?: SubgraphIR[];
+}
+interface FlowchartIR {
+    type: 'flowchart';
+    direction: FlowDirection;
+    nodes: NodeIR[];
+    edges: EdgeIR[];
+    subgraphs?: SubgraphIR[];
+}
+/** ER diagrams reuse the existing ParsedSchema shape so DbSchemaFlow can
+ *  consume the IR with zero conversion. */
+interface ERDiagramIR {
+    type: 'er';
+    schema: ParsedSchema;
+}
+interface PieSlice {
+    label: string;
+    value: number;
+}
+interface PieChartIR {
+    type: 'pie';
+    title?: string;
+    slices: PieSlice[];
+    /** Whether the percentage label was opted-in via `pie showData`. */
+    showData?: boolean;
+}
+interface QuadrantPoint {
+    label: string;
+    /** Both in 0..1 range. */
+    x: number;
+    y: number;
+}
+interface QuadrantChartIR {
+    type: 'quadrant';
+    title?: string;
+    xAxisLabel?: {
+        low: string;
+        high: string;
+    };
+    yAxisLabel?: {
+        low: string;
+        high: string;
+    };
+    /** Quadrants in standard math order: 1=top-right, 2=top-left, 3=bottom-left, 4=bottom-right. */
+    quadrantLabels?: {
+        q1?: string;
+        q2?: string;
+        q3?: string;
+        q4?: string;
+    };
+    points: QuadrantPoint[];
+}
+interface JourneyTask {
+    label: string;
+    score: number;
+    actors: string[];
+}
+interface JourneySection {
+    title: string;
+    tasks: JourneyTask[];
+}
+interface JourneyIR {
+    type: 'journey';
+    title?: string;
+    sections: JourneySection[];
+}
+type SequenceArrow = 'sync' | 'reply' | 'async' | 'cross';
+interface SequenceParticipant {
+    id: string;
+    label: string;
+}
+interface SequenceMessage {
+    kind: 'message';
+    from: string;
+    to: string;
+    arrow: SequenceArrow;
+    label: string;
+}
+interface SequenceNote {
+    kind: 'note';
+    /** Side relative to the participant(s) the note is anchored to. */
+    side: 'left' | 'right' | 'over';
+    participants: string[];
+    text: string;
+}
+type SequenceStep = SequenceMessage | SequenceNote;
+interface SequenceIR {
+    type: 'sequence';
+    title?: string;
+    participants: SequenceParticipant[];
+    steps: SequenceStep[];
+}
+/** Discriminated union of every native IR type the renderer registry knows
+ *  how to draw. Other diagram types still fall through to the mermaid
+ *  fallback path until a renderer is registered for them. */
+type ClassMemberKind = 'attribute' | 'method';
+type ClassVisibility = 'public' | 'private' | 'protected' | 'package';
+interface ClassMember {
+    kind: ClassMemberKind;
+    visibility?: ClassVisibility;
+    name: string;
+    /** Type for attributes; return-or-empty for methods. */
+    returnType?: string;
+    /** Comma-separated parameter list (string for now; we don't model them). */
+    parameters?: string;
+}
+interface ClassNode {
+    id: string;
+    label: string;
+    members: ClassMember[];
+    /** Stereotype like `<<interface>>` or `<<abstract>>`. */
+    stereotype?: string;
+}
+type ClassRelationKind = 'inheritance' | 'composition' | 'aggregation' | 'association' | 'dependency' | 'realization';
+interface ClassRelation {
+    source: string;
+    target: string;
+    kind: ClassRelationKind;
+    label?: string;
+}
+interface ClassDiagramIR {
+    type: 'class';
+    classes: ClassNode[];
+    relations: ClassRelation[];
+}
+interface StateNode {
+    id: string;
+    label: string;
+    /** Special states: [*] start/end markers; `composite` wraps nested states. */
+    kind: 'state' | 'start' | 'end' | 'choice' | 'composite';
+    /** Parent composite-state id; top-level states have none. */
+    parent?: string;
+}
+interface StateTransition {
+    source: string;
+    target: string;
+    /** Optional guard / event label. */
+    label?: string;
+    /** The composite (if any) this transition lives inside. */
+    parent?: string;
+}
+interface StateDiagramIR {
+    type: 'state';
+    states: StateNode[];
+    transitions: StateTransition[];
+}
+type GanttItemStatus = 'default' | 'active' | 'done' | 'crit' | 'milestone';
+interface GanttTask {
+    id: string;
+    label: string;
+    /** ISO date string (YYYY-MM-DD or full ISO). */
+    start: string;
+    /** ISO date string (exclusive end). For milestones equals start. */
+    end: string;
+    status: GanttItemStatus;
+    /** Group / section the task belongs to. */
+    section?: string;
+}
+interface GanttDiagramIR {
+    type: 'gantt';
+    title?: string;
+    /** Original `dateFormat` directive — informational, parser already
+     *  normalizes start/end to ISO. */
+    dateFormat?: string;
+    /** Optional axis format passed to the timeline renderer. */
+    axisFormat?: string;
+    tasks: GanttTask[];
+}
+interface TimelineEvent {
+    id: string;
+    /** Period label, e.g. "2003" / "Q1 2026" / "Day 1". */
+    period: string;
+    /** Free text describing the event(s) at this period. */
+    text: string;
+    /** Section this event belongs to, if any. */
+    section?: string;
+}
+interface TimelineIR {
+    type: 'timeline';
+    title?: string;
+    events: TimelineEvent[];
+}
+type MindmapShape = 'default' | 'square' | 'rounded' | 'circle' | 'cloud' | 'bang' | 'hexagon';
+interface MindmapNode {
+    id: string;
+    label: string;
+    shape: MindmapShape;
+    children: MindmapNode[];
+    /** Optional iconify-style ref. */
+    icon?: string;
+}
+interface MindmapIR {
+    type: 'mindmap';
+    root: MindmapNode;
+}
+type ArchSide = 'L' | 'R' | 'T' | 'B';
+interface ArchitectureNode {
+    id: string;
+    label: string;
+    kind: 'group' | 'service';
+    /** Iconify-style ref (e.g. `logos:aws-rds`, `cloud`, `database`). */
+    icon?: string;
+    /** Parent group id when nested. */
+    parent?: string;
+}
+interface ArchitectureEdge {
+    source: string;
+    target: string;
+    sourceSide?: ArchSide;
+    targetSide?: ArchSide;
+    label?: string;
+}
+interface ArchitectureIR {
+    type: 'architecture';
+    nodes: ArchitectureNode[];
+    edges: ArchitectureEdge[];
+}
+type C4Variant = 'context' | 'container' | 'component' | 'deployment';
+type C4ElementKind = 'person' | 'person-external' | 'system' | 'system-external' | 'system-db' | 'system-queue' | 'container' | 'container-external' | 'container-db' | 'container-queue' | 'component' | 'component-external' | 'component-db' | 'component-queue' | 'boundary' | 'system-boundary' | 'container-boundary' | 'enterprise-boundary' | 'node';
+interface C4Element {
+    id: string;
+    kind: C4ElementKind;
+    label: string;
+    technology?: string;
+    description?: string;
+    parent?: string;
+}
+interface C4Relation {
+    source: string;
+    target: string;
+    label?: string;
+    technology?: string;
+}
+interface C4IR {
+    type: 'c4';
+    variant: C4Variant;
+    title?: string;
+    elements: C4Element[];
+    relations: C4Relation[];
+}
+type GitGraphOp = {
+    kind: 'commit';
+    id?: string;
+    type?: 'NORMAL' | 'REVERSE' | 'HIGHLIGHT';
+    tag?: string;
+} | {
+    kind: 'branch';
+    name: string;
+} | {
+    kind: 'checkout';
+    name: string;
+} | {
+    kind: 'merge';
+    from: string;
+    tag?: string;
+} | {
+    kind: 'cherry-pick';
+    commitId: string;
+};
+interface GitGraphIR {
+    type: 'gitgraph';
+    title?: string;
+    ops: GitGraphOp[];
+}
+type DiagramIR = FlowchartIR | ERDiagramIR | PieChartIR | QuadrantChartIR | JourneyIR | SequenceIR | ClassDiagramIR | StateDiagramIR | GanttDiagramIR | TimelineIR | MindmapIR | ArchitectureIR | C4IR | GitGraphIR;
+type DiagramType = DiagramIR['type'];
+/** Surface-level diagram-type label inferred from a mermaid source string.
+ *  Includes types that have no native renderer yet (`'unsupported'`).
+ *  Used by the registry to decide whether to dispatch native or fall back. */
+type RecognizedDiagramType = DiagramType | 'sequence' | 'class' | 'state' | 'gantt' | 'pie' | 'quadrant' | 'mindmap' | 'gitgraph' | 'timeline' | 'journey' | 'c4' | 'architecture' | 'unsupported';
+/** A successful parse: the inferred type plus its IR. Every recognized type
+ *  has a native renderer, so `ir` is always populated when `ok === true`. */
+interface ParseSuccess {
+    ok: true;
+    type: DiagramType;
+    ir: DiagramIR;
+}
+interface ParseFailure {
+    ok: false;
+    error: string;
+    /** Original source preserved so callers can show diagnostics. */
+    source: string;
+}
+type ParseResult = ParseSuccess | ParseFailure;
+
+/** What every renderer exposes via a forwarded ref so the export pipeline
+ *  can serialize the diagram to SVG/PNG without knowing the renderer's
+ *  internals. */
+interface RendererHandle {
+    /** Returns an SVG element representing the diagram. For renderers that
+     *  produce a single inclusive <svg> (Sequence, Recharts, mermaid fallback)
+     *  this is the live element; for renderers that mix HTML + SVG (ReactFlow,
+     *  vis-timeline) it's a synthetic <svg> wrapping the HTML as foreignObject. */
+    getSvgElement(): SVGSVGElement | null;
+    /** Optional HTML container reference, used by the export pipeline as a
+     *  more reliable source for PNG rasterization (canvas + foreignObject is
+     *  unreliable across browsers). */
+    getHtmlContainer?(): HTMLElement | null;
+}
+/** Narrow DiagramIR to the IR variant a particular renderer accepts. */
+type IRForType<T extends DiagramType> = T extends 'flowchart' ? FlowchartIR : T extends 'er' ? ERDiagramIR : T extends 'pie' ? PieChartIR : T extends 'quadrant' ? QuadrantChartIR : T extends 'journey' ? JourneyIR : T extends 'sequence' ? SequenceIR : T extends 'class' ? ClassDiagramIR : T extends 'state' ? StateDiagramIR : T extends 'gantt' ? GanttDiagramIR : T extends 'timeline' ? TimelineIR : T extends 'mindmap' ? MindmapIR : T extends 'architecture' ? ArchitectureIR : T extends 'c4' ? C4IR : T extends 'gitgraph' ? GitGraphIR : DiagramIR;
+interface RendererProps<T extends DiagramType = DiagramType> {
+    ir: IRForType<T>;
+    /** Dark-mode flag; renderers honor it for color tokens. */
+    dark?: boolean;
+    /** Ref the renderer will populate with a RendererHandle on mount. */
+    handleRef?: RefObject<RendererHandle | null>;
+}
+interface RendererEntry<T extends DiagramType = DiagramType> {
+    type: T;
+    /** Lazy loader — only resolved when an IR of this type needs to render. */
+    loader: () => Promise<{
+        default: ComponentType<RendererProps<T>>;
+    }>;
+}
+declare function register<T extends DiagramType>(entry: RendererEntry<T>): void;
+declare function getRenderer(type: DiagramType): RendererEntry | null;
+declare function hasRenderer(type: DiagramType): boolean;
+/** Reset the registry. Test-only. */
+declare function _resetRegistry(): void;
+
+interface DiagramRendererProps {
+    /** Mermaid-syntax source string. */
+    source: string;
+    /** Dark-mode flag; threaded through to the underlying renderer. */
+    dark?: boolean;
+    /** Ref to populate with a RendererHandle so the export toolbar can grab the SVG. */
+    handleRef?: RefObject<RendererHandle | null>;
+    /** Optional `onError` for parse / render failures. */
+    onError?: (message: string) => void;
+}
+/**
+ * Dispatch component. Parses the source to a DiagramIR, then delegates to
+ * the matching renderer in the registry.
+ *
+ * Every diagram type the registry knows about renders natively — there is
+ * no mermaid fallback. Unrecognized sources surface a clear error.
+ */
+declare function DiagramRenderer({ source, dark, handleRef, onError }: DiagramRendererProps): react_jsx_runtime.JSX.Element;
+
+type SvgSource = string | SVGSVGElement | (() => SVGSVGElement | null);
+interface PngOptions {
+    /** Canvas resolution multiplier. Default: 2 (Retina-friendly). */
+    scale?: number;
+    /** Background color. Pass `null` for transparent. Default: `'#ffffff'`. */
+    background?: string | null;
+}
+interface SvgStringOptions {
+    /**
+     * When the source is a DOM element, copy `getComputedStyle()` values onto
+     * inline `style="…"` attributes so the standalone SVG carries its own
+     * presentation. Set to `false` if the source is already self-contained
+     * (e.g. SVG built by a custom renderer that emits inline attributes).
+     * Default: true.
+     */
+    inlineStyles?: boolean;
+    /**
+     * Strip <foreignObject> elements from the output. Required for canvas-based
+     * PNG conversion (browsers can't rasterize foreignObject). Default: true.
+     */
+    stripForeignObject?: boolean;
+}
+declare const INLINEABLE_STYLE_PROPS: readonly string[];
+/**
+ * Convert any `SvgSource` to a self-contained SVG string.
+ *
+ * Pipeline for DOM sources:
+ *   1. Clone the element (no live-DOM mutation)
+ *   2. Ensure xmlns / xmlns:xlink namespace declarations are present
+ *   3. Walk live + clone in parallel and inline computed styles onto the clone
+ *   4. Strip <foreignObject> children (break canvas-based PNG conversion)
+ *   5. Serialize via XMLSerializer
+ */
+declare function toSvgString(source: SvgSource, options?: SvgStringOptions): string;
+/**
+ * Extracts intrinsic dimensions from an SVG string.
+ * Preference: viewBox → width/height attributes → fallback (800×600).
+ *
+ * Uses regex rather than DOMParser to stay bulletproof across XML namespace
+ * quirks (jsdom's DOMParser is fussier than browser DOMParser about
+ * `image/svg+xml` parse mode + querySelector).
+ */
+declare function getSvgDimensions(svg: string): {
+    width: number;
+    height: number;
+};
+/** Convert an SVG string to a PNG `Blob` via an offscreen `<canvas>`. */
+declare function svgToPngBlob(svg: string, options?: PngOptions): Promise<Blob>;
+/** Download the SVG as a file. Preserves <foreignObject> so renderers that
+ *  embed HTML (ReactFlow nodes, vis-timeline) export their full visual,
+ *  not just the edges layer. */
+declare function downloadSvg(source: SvgSource, filename: string): Promise<void>;
+/** Download the diagram as PNG. */
+declare function downloadPng(source: SvgSource, filename: string, options?: PngOptions): Promise<void>;
+/** Copy the SVG markup to the clipboard as plain text. */
+declare function copySvgToClipboard(source: SvgSource): Promise<void>;
+/** Copy the diagram to the clipboard as a PNG image. */
+declare function copyPngToClipboard(source: SvgSource, options?: PngOptions): Promise<void>;
+
+interface DiagramExportToolbarProps {
+    source: SvgSource;
+    /** Filename prefix (no extension). Default: "diagram". */
+    filenameBase?: string;
+    /** PNG canvas resolution multiplier. Default: 2. */
+    pngScale?: number;
+    /** PNG background color. Pass `null` for transparent. Default: white. */
+    pngBackground?: string | null;
+    /** Outer container class (positioning, opacity, etc.). */
+    className?: string;
+    /** Called when an export operation throws. Default: silent. */
+    onError?: (error: Error) => void;
+}
+declare function DiagramExportToolbar({ source, filenameBase, pngScale, pngBackground, className, onError, }: DiagramExportToolbarProps): react_jsx_runtime.JSX.Element;
+
+type FlowchartRendererProps = RendererProps<'flowchart'>;
+declare function FlowchartRenderer({ ir, dark, handleRef }: FlowchartRendererProps): react_jsx_runtime.JSX.Element;
+
+type ERRendererProps = RendererProps<'er'>;
+declare function ERRenderer({ ir, dark, handleRef }: ERRendererProps): react_jsx_runtime.JSX.Element;
+
+type PieRendererProps = RendererProps<'pie'>;
+declare function PieRenderer({ ir, dark, handleRef }: PieRendererProps): react_jsx_runtime.JSX.Element;
+
+type QuadrantRendererProps = RendererProps<'quadrant'>;
+declare function QuadrantRenderer({ ir, dark, handleRef }: QuadrantRendererProps): react_jsx_runtime.JSX.Element;
+
+type JourneyRendererProps = RendererProps<'journey'>;
+declare function JourneyRenderer({ ir, dark, handleRef }: JourneyRendererProps): react_jsx_runtime.JSX.Element;
+
+type SequenceRendererProps = RendererProps<'sequence'>;
+declare function SequenceRenderer({ ir, dark, handleRef }: SequenceRendererProps): react_jsx_runtime.JSX.Element;
+
+type ClassRendererProps = RendererProps<'class'>;
+declare function ClassRenderer({ ir, dark, handleRef }: ClassRendererProps): react_jsx_runtime.JSX.Element;
+
+type StateRendererProps = RendererProps<'state'>;
+declare function StateRenderer({ ir, dark, handleRef }: StateRendererProps): react_jsx_runtime.JSX.Element;
+
+type GanttRendererProps = RendererProps<'gantt'>;
+declare function GanttRenderer({ ir, dark, handleRef }: GanttRendererProps): react_jsx_runtime.JSX.Element;
+
+type TimelineRendererProps = RendererProps<'timeline'>;
+declare function TimelineRenderer({ ir, dark, handleRef }: TimelineRendererProps): react_jsx_runtime.JSX.Element;
+
+type MindmapRendererProps = RendererProps<'mindmap'>;
+declare function MindmapRenderer({ ir, dark, handleRef }: MindmapRendererProps): react_jsx_runtime.JSX.Element;
+
+type ArchitectureRendererProps = RendererProps<'architecture'>;
+declare function ArchitectureRenderer({ ir, dark, handleRef }: ArchitectureRendererProps): react_jsx_runtime.JSX.Element;
+
+type C4RendererProps = RendererProps<'c4'>;
+declare function C4Renderer({ ir, dark, handleRef }: C4RendererProps): react_jsx_runtime.JSX.Element;
+
+type GitGraphRendererProps = RendererProps<'gitgraph'>;
+declare function GitGraphRenderer({ ir, dark, handleRef }: GitGraphRendererProps): react_jsx_runtime.JSX.Element;
+
+declare function bootstrapDiagramRenderers(): void;
+
+declare function detectDiagramType(source: string): Promise<RecognizedDiagramType | null>;
+declare function parseToIR(source: string): Promise<ParseResult>;
+
+interface BuildOptions$1 {
+    dark?: boolean;
+    padding?: number;
+}
+/** One-call flowchart → SVG. Internally runs dagre layout. */
+declare function flowchartToSvg(ir: FlowchartIR, options?: BuildOptions$1): string;
+/** One-call class diagram → SVG. */
+declare function classToSvg(ir: ClassDiagramIR, options?: BuildOptions$1): string;
+/** One-call ER diagram → SVG. */
+declare function erToSvg(ir: ERDiagramIR, options?: BuildOptions$1): string;
+
+interface BuildOptions {
+    dark?: boolean;
+    /** Outer canvas padding around the bounding box. Default: 32. */
+    padding?: number;
+}
+declare function buildFlowchartSvg(ir: FlowchartIR, positions: Map<string, {
+    x: number;
+    y: number;
+}>, options?: BuildOptions): string;
+interface StateBuildPositions {
+    /** Top-level nodes: absolute top-left. */
+    topLevel: Map<string, {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    /** Children inside composites: position relative to composite top-left. */
+    children: Map<string, {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        parent: string;
+    }>;
+}
+declare function buildStateSvg(ir: StateDiagramIR, positions: StateBuildPositions, options?: BuildOptions): string;
+declare function buildClassSvg(ir: ClassDiagramIR, positions: Map<string, {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>, options?: BuildOptions): string;
+declare function buildErSvg(ir: ERDiagramIR, positions: Map<string, {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>, options?: BuildOptions): string;
+declare function buildMindmapSvg(ir: MindmapIR, positions: Map<string, {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    depth: number;
+}>, options?: BuildOptions): string;
+declare function buildGanttSvg(ir: GanttDiagramIR, options?: BuildOptions): string;
+declare function buildTimelineSvg(ir: TimelineIR, options?: BuildOptions): string;
+declare function buildPieSvg(ir: PieChartIR, options?: BuildOptions): string;
+declare function buildQuadrantSvg(ir: QuadrantChartIR, options?: BuildOptions): string;
+declare function buildJourneySvg(ir: JourneyIR, options?: BuildOptions): string;
+declare function buildArchitectureSvg(ir: ArchitectureIR, options?: BuildOptions): string;
+declare function buildC4Svg(ir: C4IR, options?: BuildOptions): string;
+declare function buildGitGraphSvg(ir: GitGraphIR, options?: BuildOptions): string;
+/** Parse an SVG string to an SVGSVGElement so it can flow through the
+ *  centralized export pipeline (which expects a DOM element). */
+declare function svgStringToElement(svg: string): SVGSVGElement | null;
+
+interface NodeSize {
+    width: number;
+    height: number;
+}
+interface LayoutResult {
+    /** Absolute top-left coordinates per node id. */
+    nodePositions: Map<string, {
+        x: number;
+        y: number;
+    }>;
+    /** Bounding box of the entire graph (post-padding). */
+    width: number;
+    height: number;
+}
+interface DagreLayoutOptions {
+    /** Default node size when not provided per-node. */
+    defaultNodeSize?: NodeSize;
+    /** Map of nodeId → { width, height }. Falls back to defaultNodeSize. */
+    nodeSizes?: Map<string, NodeSize>;
+    /** Spacing between sibling nodes in the same rank. Default: 60. */
+    nodeSeparation?: number;
+    /** Spacing between ranks. Default: 80. */
+    rankSeparation?: number;
+    /** Outer margin. Default: 24. */
+    margin?: number;
+}
+declare function layoutFlowchart(ir: FlowchartIR, options?: DagreLayoutOptions): LayoutResult;
+
+/** Reads the current dark-mode flag from the `<html>` `.dark` class. */
+declare function isDarkMode(): boolean;
+/**
+ * Observes class changes on the `<html>` element and invokes the callback
+ * whenever the `.dark` class toggles. Returns a disposer.
+ */
+declare function watchDarkMode(callback: (dark: boolean) => void): () => void;
+
+interface KindStyle {
+    border: string;
+    headerBg: string;
+    accent: string;
+    bodyBg: string;
+    text: string;
+    iconColor: string;
+}
+interface ThemePalette {
+    canvasBg: string;
+    edgeColor: string;
+    edgeLabel: string;
+    edgeLabelBg: string;
+    subgraphBg: string;
+    subgraphBorder: string;
+    subgraphLabel: string;
+    nodeShadow: string;
+    byKind: Record<NodeKind, KindStyle>;
+}
+declare function getDiagramTheme(dark: boolean): ThemePalette;
+
+export { type ArchSide, type ArchitectureEdge, type ArchitectureIR, type ArchitectureNode, ArchitectureRenderer, type C4Element, type C4ElementKind, type C4IR, type C4Relation, C4Renderer, type C4Variant, type ClassDiagramIR, type ClassMember, type ClassMemberKind, type ClassNode, type ClassRelation, type ClassRelationKind, ClassRenderer, type ClassVisibility, type DbColumn, type DbRelation, type DbTable, DiagramExportToolbar, type DiagramIR, DiagramRenderer, type DiagramType, type ERDiagramIR, ERRenderer, type EdgeArrow, type EdgeIR, type EdgeKind, type FlowDirection, type FlowchartIR, FlowchartRenderer, type GanttDiagramIR, type GanttItemStatus, GanttRenderer, type GanttTask, type GitGraphIR, type GitGraphOp, GitGraphRenderer, INLINEABLE_STYLE_PROPS, type IRForType, type JourneyIR, JourneyRenderer, type JourneySection, type JourneyTask, type MindmapIR, type MindmapNode, MindmapRenderer, type MindmapShape, type NodeIR, type NodeKind, type NodeSize, type ParseFailure, type ParseResult, type ParseSuccess, type ParsedSchema, type PieChartIR, PieRenderer, type PieSlice, type PngOptions, type QuadrantChartIR, type QuadrantPoint, QuadrantRenderer, type RecognizedDiagramType, type RendererEntry, type RendererHandle, type RendererProps, type SequenceArrow, type SequenceIR, type SequenceMessage, type SequenceNote, type SequenceParticipant, SequenceRenderer, type SequenceStep, type StateBuildPositions, type StateDiagramIR, type StateNode, StateRenderer, type StateTransition, type SubgraphIR, type SvgSource, type SvgStringOptions, type TimelineEvent, type TimelineIR, TimelineRenderer, _resetRegistry, bootstrapDiagramRenderers, buildArchitectureSvg, buildC4Svg, buildClassSvg, buildErSvg, buildFlowchartSvg, buildGanttSvg, buildGitGraphSvg, buildJourneySvg, buildMindmapSvg, buildPieSvg, buildQuadrantSvg, buildStateSvg, buildTimelineSvg, classToSvg, copyPngToClipboard, copySvgToClipboard, detectDiagramType, downloadPng, downloadSvg, erToSvg, flowchartToSvg, getDiagramTheme, getRenderer, getSvgDimensions, hasRenderer, isDarkMode, layoutFlowchart, parseToIR, register, svgStringToElement, svgToPngBlob, toSvgString, watchDarkMode };