@zombie-mermaid/mermaid-parser 2.2.1

package/dist/index.d.ts

@@ -0,0 +1,879 @@
+import { Direction } from '@zombie-mermaid/core';
+import { NodeInteraction } from '@zombie-mermaid/core';
+import { NodeShape } from '@zombie-mermaid/core';
+import { Statement } from '@zombie-mermaid/core';
+import { StyleDirectives } from '@zombie-mermaid/core';
+
+/** Narrow rectangle on a lifeline showing active processing */
+export declare interface Activation {
+    actorId: string;
+    x: number;
+    topY: number;
+    bottomY: number;
+    width: number;
+}
+
+export declare interface ActivationCheckResult {
+    /** true when every activation is balanced (no issues found). */
+    ok: boolean;
+    issues: ActivationIssue[];
+}
+
+/**
+ * One standalone `activate X` (`kind: 'start'`) or `deactivate X`
+ * (`kind: 'end'`) statement. Mermaid's own grammar expands the `+`/`-` arrow
+ * shorthand into exactly these events — `A->>+B` is a message followed by an
+ * `activeStart` for the recipient, `A-->>-B` a message followed by an
+ * `activeEnd` for the sender — so this is the primitive and the shorthand is
+ * sugar over it.
+ */
+export declare interface ActivationEvent {
+    actorId: string;
+    kind: 'start' | 'end';
+    /**
+     * Index of the message this statement follows (-1 if it precedes every
+     * message). The activation bar starts/ends at that message's row, which
+     * is where the shorthand form's bar starts/ends too.
+     */
+    afterIndex: number;
+}
+
+export declare interface ActivationFixResult {
+    /** true when the returned diagram has no remaining activation issues. */
+    ok: boolean;
+    /** Original diagram, unchanged if there was nothing fixable. */
+    originalDiagram: string;
+    /**
+     * Diagram with a "deactivate X" statement appended for every
+     * DANGLING_ACTIVATION issue found. Identical to `originalDiagram` when
+     * there was nothing to fix.
+     */
+    fixedDiagram: string;
+    /** Human-readable description of each fix actually applied. */
+    fixesApplied: string[];
+    /**
+     * Issues that could not be auto-fixed (currently always
+     * UNMATCHED_DEACTIVATION — see module header). Empty when `ok` is true.
+     */
+    remainingIssues: ActivationIssue[];
+}
+
+export declare interface ActivationIssue {
+    code: ActivationIssueCode;
+    /** Actor whose activation is unbalanced. */
+    actorId: string;
+    /** Human-readable explanation, including a source-position hint. */
+    message: string;
+}
+
+export declare type ActivationIssueCode = 'DANGLING_ACTIVATION' | 'UNMATCHED_DEACTIVATION';
+
+export declare interface Actor {
+    id: string;
+    label: string;
+    /** 'participant' renders as a box, 'actor' renders as a stick figure */
+    type: 'participant' | 'actor';
+    /**
+     * Index of the message that creates this participant (`create participant
+     * X` on the line before it). The participant's box is drawn at that
+     * message's row instead of in the header, and its lifeline starts there.
+     * Unset for participants that exist from the top of the diagram.
+     */
+    createdAt?: number;
+    /**
+     * Index of the message that destroys this participant (`destroy X` on the
+     * line before it). Its lifeline ends at that message's row with a cross,
+     * and no footer box is drawn. Unset for participants that live to the end.
+     */
+    destroyedAt?: number;
+}
+
+export declare interface AxisTick {
+    /** Label text for this tick */
+    label: string;
+    /** Position of the tick mark on the axis */
+    x: number;
+    y: number;
+    /** End of the tick mark (short perpendicular line) */
+    tx: number;
+    ty: number;
+    /** Label anchor position */
+    labelX: number;
+    labelY: number;
+    /** Text anchor for label */
+    textAnchor: 'start' | 'middle' | 'end';
+}
+
+export declare interface Block {
+    /** Block type keyword */
+    type: 'loop' | 'alt' | 'opt' | 'par' | 'critical' | 'break' | 'rect';
+    /** Label for the block header */
+    label: string;
+    /** Index of the first message inside this block */
+    startIndex: number;
+    /** Index of the last message inside this block (inclusive) */
+    endIndex: number;
+    /** For alt/par blocks: indices where "else"/"and" dividers appear (message indices) */
+    dividers: Array<{
+        index: number;
+        label: string;
+    }>;
+}
+
+/**
+ * Cardinality notation (crow's foot):
+ *   'one'       ||  ||  exactly one
+ *   'zero-one'  |o  o|  zero or one
+ *   'many'      }|  |{  one or more
+ *   'zero-many' }o  o{  zero or more
+ */
+export declare type Cardinality = 'one' | 'zero-one' | 'many' | 'zero-many';
+
+/** Default accent for charts when the theme doesn't provide one. */
+export declare const CHART_ACCENT_FALLBACK = "#3b82f6";
+
+/**
+ * Check a parsed sequence diagram for activation/deactivation imbalance.
+ *
+ * Merges the inline `+`/`-` arrow shorthand (`Message.activate` /
+ * `Message.deactivate`) with standalone `activate X` / `deactivate X`
+ * statements (`SequenceDiagram.activations`) into one chronological event
+ * stream per actor — the same merge `layout.ts` performs to position
+ * activation bars — then walks a stack per actor:
+ *
+ * - A `deactivate` with nothing open on that actor's stack is reported as
+ *   `UNMATCHED_DEACTIVATION` (the renderer silently ignores this case —
+ *   see `endActivation` in layout.ts — this check surfaces it instead).
+ * - Anything left on a stack once every message has been processed is
+ *   reported as `DANGLING_ACTIVATION` (the renderer draws these extending
+ *   to the bottom of the diagram, which usually isn't what the author
+ *   intended).
+ */
+export declare function checkActivationBalance(diagram: SequenceDiagram): ActivationCheckResult;
+
+/**
+ * Parsed class diagram — logical structure from mermaid text.
+ *
+ * Extends {@link StyleDirectives} so `classDef` / `cssClass` / `style` /
+ * `:::` resolve through the same cascade flowcharts use (see
+ * packages/core/src/style-directives.ts).
+ */
+export declare interface ClassDiagram extends StyleDirectives {
+    /** All class definitions */
+    classes: ClassNode[];
+    /** Relationships between classes */
+    relationships: ClassRelationship[];
+    /** Optional namespace groupings */
+    namespaces: ClassNamespace[];
+    /** Maps class IDs to interactions declared by `click` statements */
+    interactions: Map<string, NodeInteraction>;
+    /** Notes, in source order — `note "text"` and `note for X "text"` */
+    notes: ClassNote[];
+}
+
+export declare interface ClassMember {
+    /** Visibility: + public, - private, # protected, ~ package */
+    visibility: '+' | '-' | '#' | '~' | '';
+    /** Member name */
+    name: string;
+    /** Type annotation (e.g., "String", "int", "void") */
+    type?: string;
+    /** Whether the member is static (underlined in UML) */
+    isStatic?: boolean;
+    /** Whether the member is abstract (italic in UML) */
+    isAbstract?: boolean;
+    /** Whether the member is a method (renders with parentheses) */
+    isMethod?: boolean;
+    /** Method parameters (e.g., "data", "key, val") — only for methods */
+    params?: string;
+}
+
+export declare interface ClassNamespace {
+    name: string;
+    classIds: string[];
+}
+
+export declare interface ClassNode {
+    id: string;
+    label: string;
+    /** Annotation like <<interface>>, <<abstract>>, <<service>>, <<enumeration>> */
+    annotation?: string;
+    /** Class attributes (fields/properties) */
+    attributes: ClassMember[];
+    /** Class methods (functions) */
+    methods: ClassMember[];
+}
+
+/**
+ * A class-diagram note. Mermaid lays an attached note out as its own node
+ * joined to the class by a dotted, arrowless link (classDb.getData); a free
+ * note is a lone node.
+ */
+export declare interface ClassNote {
+    /** Note text; `\n` / `<br/>` in the source are already normalized to newlines */
+    text: string;
+    /** Class this note is attached to (`note for X`); absent for a free note */
+    forClass?: string;
+}
+
+export declare interface ClassRelationship {
+    from: string;
+    to: string;
+    type: RelationshipType;
+    /**
+     * Which end of the relationship line has the UML marker (triangle, diamond, arrow).
+     * Determined by the arrow syntax direction:
+     *   - Prefix markers like `<|--`, `*--`, `o--` → 'from' (marker on left/from side)
+     *   - Suffix markers like `..|>`, `-->`, `..>`, `--*`, `--o` → 'to' (marker on right/to side)
+     */
+    markerAt: 'from' | 'to';
+    /** Label on the relationship line */
+    label?: string;
+    /** Cardinality at the "from" end (e.g., "1", "*", "0..1") */
+    fromCardinality?: string;
+    /** Cardinality at the "to" end */
+    toCardinality?: string;
+}
+
+export declare interface ErAttribute {
+    /** Data type (string, int, varchar, etc.) */
+    type: string;
+    /** Attribute name */
+    name: string;
+    /** Key constraints: PK, FK, UK */
+    keys: Array<'PK' | 'FK' | 'UK'>;
+    /** Optional comment */
+    comment?: string;
+}
+
+/** Parsed ER diagram — logical structure from mermaid text */
+export declare interface ErDiagram {
+    /** All entity definitions */
+    entities: ErEntity[];
+    /** Relationships between entities */
+    relationships: ErRelationship[];
+    /**
+     * Overall layout direction, from a top-level `direction TB` / `direction LR`
+     * / `direction BT` / `direction RL` statement. `undefined` when the diagram
+     * doesn't specify one, in which case the layout falls back to its default.
+     */
+    direction?: Direction;
+}
+
+export declare interface ErEntity {
+    id: string;
+    /** Display name (same as id unless aliased) */
+    label: string;
+    /** Entity attributes (columns) */
+    attributes: ErAttribute[];
+}
+
+export declare interface ErRelationship {
+    entity1: string;
+    entity2: string;
+    /** Cardinality at entity1's end */
+    cardinality1: Cardinality;
+    /** Cardinality at entity2's end */
+    cardinality2: Cardinality;
+    /** Relationship verb/label (e.g., "places", "contains") */
+    label: string;
+    /** Whether the relationship is identifying (solid line) or non-identifying (dashed) */
+    identifying: boolean;
+}
+
+/** The metadata a `@{ ... }` block can carry. */
+export declare interface ExpandedNodeMeta {
+    shape?: string;
+    label?: string;
+    icon?: string;
+    img?: string;
+    /** Outline drawn around an icon or image: `square`, `circle`, `rounded`. */
+    form?: string;
+    /** Explicit width/height for an image node. */
+    w?: string;
+    h?: string;
+    /** Image fit mode Mermaid accepts alongside `img`. */
+    constraint?: string;
+    /** Any other key seen, preserved rather than dropped. */
+    [key: string]: string | undefined;
+}
+
+/**
+ * Check a Mermaid sequence diagram for activation/deactivation imbalance
+ * and, where mechanically safe, return a corrected version.
+ *
+ * Throws the same way `parseSequenceDiagram`/`detectDiagramType` do on
+ * invalid or non-sequence input — callers (e.g. the MCP tool handler) are
+ * expected to catch and translate, matching `check-sequence-activations.ts`'s
+ * own error handling.
+ */
+export declare function fixActivationBalance(sourceDiagram: string): ActivationFixResult;
+
+/** Format a class member as a display string: visibility + name(+params for methods) + optional type */
+export declare function formatClassMember(m: ClassMember): string;
+
+/**
+ * Get the hex color for a series index.
+ * Index 0 returns the accent color as-is.
+ * Index 1+ alternate between darker and lighter shades of the same hue
+ * with subtle hue drift (±8-12° per tier) to stay in the same family.
+ *
+ * When `bgColor` is provided, shade direction adapts to the background:
+ *   - Light bg: odd = darker, even = lighter (default)
+ *   - Dark bg:  odd = lighter, even = darker (so shades stay visible)
+ */
+export declare function getSeriesColor(index: number, accentColor: string, bgColor?: string): string;
+
+export declare interface GridLine {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+
+/**
+ * Narrow a regex-captured block keyword to `Block['type']`. The capturing
+ * regex at the call site uses the same `(loop|alt|opt|par|critical|break|
+ * rect)` alternation, so the input is always one of these seven values in
+ * practice — but the match itself is typed as `string`.
+ *
+ * Exported for direct unit testing (see
+ * src/__tests__/sequence-parser.test.ts) — not otherwise part of this
+ * module's public parsing API.
+ */
+export declare function isBlockType(value: string): value is Block['type'];
+
+/** Whether `value` is a colour this renderer will emit as-is (case-insensitive). */
+export declare function isCssColor(value: string): boolean;
+
+/**
+ * Detect whether a background color is dark (lightness < 50%).
+ */
+export declare function isDarkBackground(bgHex: string): boolean;
+
+/** Check whether a string is a valid 6-digit hex color (e.g. "#3b82f6"). */
+export declare function isValidHex(color: string): boolean;
+
+/** Every shape name this renderer accepts, for documentation and tests. */
+export declare function knownShapeNames(): string[];
+
+export declare interface LegendItem {
+    /** Display label */
+    label: string;
+    /** Position of the swatch/icon */
+    x: number;
+    y: number;
+    /** Series type determines swatch shape (rect for bar, line+dot for line) */
+    type: 'bar' | 'line';
+    /** Series index within its type (for layout grouping) */
+    seriesIndex: number;
+    /** Global color index across all series (for unified color assignment) */
+    colorIndex: number;
+}
+
+/** Vertical dashed line from actor to bottom of diagram */
+export declare interface Lifeline {
+    actorId: string;
+    x: number;
+    topY: number;
+    bottomY: number;
+    /**
+     * Set when the actor is destroyed mid-diagram (`Actor.destroyedAt`):
+     * `bottomY` is then the destroying message's row rather than the diagram
+     * bottom, and the renderer marks it with a cross.
+     */
+    destroyed?: boolean;
+}
+
+/**
+ * Find the `@{ ... }` block at the start of `text`, returning its body and
+ * total length.
+ *
+ * Brace matching is depth-aware and quote-aware, so a label containing `}`
+ * (`A@{ label: "a } b" }`) does not terminate the block early. Returns
+ * `undefined` if `text` does not open with `@{` or the block is unterminated.
+ */
+export declare function matchExpandedBlock(text: string): {
+    body: string;
+    length: number;
+} | undefined;
+
+export declare interface Message {
+    from: string;
+    to: string;
+    label: string;
+    /** Arrow style: solid line or dashed line */
+    lineStyle: 'solid' | 'dashed';
+    /** Arrow head: filled (closed) or open */
+    arrowHead: 'filled' | 'open';
+    /**
+     * Set for a "lost message" cross-terminator (`-x`/`--x`). `arrowHead`
+     * stays `'filled'` for these (unchanged, to preserve existing SVG output)
+     * — this flag lets the ASCII renderer draw a distinct cross glyph instead
+     * of the plain filled arrowhead it shares with `->>`/`-->>`. See issue
+     * #330; not yet modeled by the SVG renderer's markers.
+     */
+    isLost?: boolean;
+    /** Activate the target lifeline (+) */
+    activate?: boolean;
+    /** Deactivate the source lifeline (-) */
+    deactivate?: boolean;
+    /** Bidirectional arrow (`<<->>` or `<<-->>`) — draw an arrow head on both ends */
+    bidirectional?: boolean;
+    /** Sequence number to display next to this arrow when `autonumber` is active */
+    seqNumber?: number;
+}
+
+/**
+ * Mix two hex colors in RGB space.
+ * `ratio` controls how much of `fgHex` shows: 0 = pure bg, 1 = pure fg.
+ * Equivalent to alpha-compositing fg over bg at the given opacity.
+ */
+export declare function mixHexColors(bgHex: string, fgHex: string, ratio: number): string;
+
+export declare interface Note {
+    /** Which actor(s) the note is attached to */
+    actorIds: string[];
+    /** Note text content */
+    text: string;
+    /** Position relative to the actor(s) */
+    position: 'left' | 'right' | 'over';
+    /** Message index after which this note appears */
+    afterIndex: number;
+}
+
+/**
+ * Split the text after the `box` keyword into a colour and a label, per
+ * Mermaid's `parseBoxData`: the leading word (or function call) is the
+ * colour if it is one, otherwise the whole header is the label. An explicit
+ * `transparent` is consumed as "no colour" so `box transparent Aqua` yields
+ * a colourless box labelled `Aqua`, exactly as upstream documents.
+ */
+export declare function parseBoxHeader(header: string): {
+    color?: string;
+    label: string;
+};
+
+/**
+ * Parse a Mermaid class diagram.
+ * Expects the first line to be "classDiagram".
+ */
+export declare function parseClassDiagram(lines: Statement[]): ClassDiagram;
+
+/**
+ * Parse a Mermaid ER diagram.
+ * Expects the first line to be "erDiagram".
+ */
+export declare function parseErDiagram(lines: Statement[]): ErDiagram;
+
+/**
+ * Parse the body of a `@{ ... }` block into key/value pairs.
+ *
+ * The body is a comma-separated list of `key: value`. Values may be quoted
+ * with `"` or `'`, and a quoted value may contain commas, colons, and braces
+ * — which is why this is a scanner rather than a `split(',')`.
+ *
+ * Mermaid also accepts a bare value with no key as shorthand for the shape
+ * (`A@{ rounded }`); that is handled by the caller, which sees an entry with
+ * an empty key.
+ */
+export declare function parseExpandedMeta(body: string): ExpandedNodeMeta;
+
+/**
+ * Convert mermaid's `~T~` generic syntax to the `<T>` form mermaid itself
+ * renders — `List~Observer~` → `List<Observer>`, `Map~K,V~` → `Map<K,V>`,
+ * `List~List~T~~` → `List<List<T>>`.
+ *
+ * Port of mermaid's `parseGenericTypes` (packages/mermaid/src/diagrams/
+ * common/common.ts): the text is split on commas so a comma *inside* a
+ * generic (`Map~K,V~`) can be re-joined with its neighbors — two adjacent
+ * comma-separated pieces that each carry exactly one `~` are the two halves
+ * of one generic — before each piece's `~` pairs are converted outermost-first.
+ */
+export declare function parseGenericTypes(input: string): string;
+
+/**
+ * Parse a Mermaid sequence diagram.
+ * Expects the first line to be "sequenceDiagram".
+ */
+export declare function parseSequenceDiagram(lines: Statement[]): SequenceDiagram;
+
+/**
+ * Parse a Mermaid xychart-beta diagram from preprocessed lines.
+ * Lines should already be trimmed and comment-stripped.
+ */
+export declare function parseXYChart(lines: Statement[]): XYChart;
+
+/** A `box … end` group of participants (Mermaid's "Grouping / Box"). */
+export declare interface ParticipantBox {
+    /** Descriptive label; empty when the box has none. */
+    label: string;
+    /**
+     * Validated CSS colour (named, `#hex`, `rgb()`/`rgba()`, `hsl()`/`hsla()`)
+     * exactly as written. Unset for a transparent box — including an explicit
+     * `box transparent …`, and any first word that isn't a colour, which then
+     * counts as the start of the label (Mermaid's `parseBoxData` rule).
+     */
+    color?: string;
+    /** Ids of the participants declared (or first used) inside the box. */
+    actorIds: string[];
+}
+
+export declare interface PlotArea {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+export declare interface PositionedActor {
+    id: string;
+    label: string;
+    type: 'participant' | 'actor';
+    /** Center x of the actor box */
+    x: number;
+    /** Top y of the actor box */
+    y: number;
+    width: number;
+    height: number;
+}
+
+export declare interface PositionedAxis {
+    /** Optional axis title text and position */
+    title?: {
+        text: string;
+        x: number;
+        y: number;
+        rotate?: number;
+    };
+    /** Tick positions along the axis */
+    ticks: AxisTick[];
+    /** Axis line: start and end coordinates */
+    line: {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+}
+
+export declare interface PositionedBar {
+    /** Bar rectangle in SVG coordinates */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Original data value */
+    value: number;
+    /** Category label for this bar (e.g. "Jan") */
+    label?: string;
+    /** Series index within bar type (for layout grouping) */
+    seriesIndex: number;
+    /** Global color index across all series */
+    colorIndex: number;
+}
+
+export declare interface PositionedBlock {
+    type: Block['type'];
+    label: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Divider lines within the block (for alt/par) */
+    dividers: Array<{
+        y: number;
+        label: string;
+    }>;
+}
+
+export declare interface PositionedClassDiagram {
+    width: number;
+    height: number;
+    classes: PositionedClassNode[];
+    relationships: PositionedClassRelationship[];
+    notes: PositionedClassNote[];
+}
+
+export declare interface PositionedClassNode {
+    id: string;
+    label: string;
+    annotation?: string;
+    attributes: ClassMember[];
+    methods: ClassMember[];
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Height of the header section (name + annotation) */
+    headerHeight: number;
+    /** Height of the attributes section */
+    attrHeight: number;
+    /** Height of the methods section */
+    methodHeight: number;
+    /** Interaction from a `click` statement — an href wraps the class box in an <a> */
+    interaction?: NodeInteraction;
+    /** Inline styles resolved from classDef + `style` statements — override theme defaults */
+    inlineStyle?: Record<string, string>;
+    /** Style class assigned via `cssClass`, `class A name`, or `:::name` — emitted onto the group's `class` attribute so external CSS can target it */
+    className?: string;
+}
+
+export declare interface PositionedClassNote {
+    /** Layout id — never collides with a class id (class ids contain no spaces) */
+    id: string;
+    text: string;
+    /** Class this note is attached to, when that class exists in the diagram */
+    forClass?: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Routed path of the dotted note→class link; absent for a free note */
+    linkPoints?: Array<{
+        x: number;
+        y: number;
+    }>;
+}
+
+export declare interface PositionedClassRelationship {
+    from: string;
+    to: string;
+    type: RelationshipType;
+    /** Which end of the line has the UML marker — propagated from ClassRelationship */
+    markerAt: 'from' | 'to';
+    label?: string;
+    fromCardinality?: string;
+    toCardinality?: string;
+    /** Path points from source to target */
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+    /** ELK-computed label center position (avoids overlaps between nearby edges) */
+    labelPosition?: {
+        x: number;
+        y: number;
+    };
+}
+
+export declare interface PositionedErDiagram {
+    width: number;
+    height: number;
+    entities: PositionedErEntity[];
+    relationships: PositionedErRelationship[];
+}
+
+export declare interface PositionedErEntity {
+    id: string;
+    label: string;
+    attributes: ErAttribute[];
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Height of the header row */
+    headerHeight: number;
+    /** Height per attribute row */
+    rowHeight: number;
+}
+
+export declare interface PositionedErRelationship {
+    entity1: string;
+    entity2: string;
+    cardinality1: Cardinality;
+    cardinality2: Cardinality;
+    label: string;
+    identifying: boolean;
+    /** Path points from entity1 to entity2 */
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+}
+
+export declare interface PositionedLine {
+    /** Polyline points */
+    points: Array<{
+        x: number;
+        y: number;
+        value: number;
+        label?: string;
+    }>;
+    /** Series index within line type (for layout grouping) */
+    seriesIndex: number;
+    /** Global color index across all series */
+    colorIndex: number;
+}
+
+export declare interface PositionedMessage {
+    from: string;
+    to: string;
+    label: string;
+    lineStyle: 'solid' | 'dashed';
+    arrowHead: 'filled' | 'open';
+    /** Start point (from actor's lifeline) */
+    x1: number;
+    /** End point (to actor's lifeline) */
+    x2: number;
+    /** Vertical position */
+    y: number;
+    /** Whether this is a self-message (same actor) */
+    isSelf: boolean;
+    /** Bidirectional arrow (`<<->>` or `<<-->>`) — draw an arrow head on both ends */
+    bidirectional: boolean;
+    /** Sequence number to display next to this arrow when `autonumber` is active */
+    seqNumber?: number;
+}
+
+export declare interface PositionedNote {
+    text: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Actor IDs this note is attached to (for SVG attribution) */
+    actors?: string[];
+    /** Note position relative to actors (for SVG attribution) */
+    position?: 'left' | 'right' | 'over';
+}
+
+/** A positioned `box … end` group: a full-height background behind its participants. */
+export declare interface PositionedParticipantBox {
+    label: string;
+    /** See {@link ParticipantBox.color}. */
+    color?: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+export declare interface PositionedSequenceDiagram {
+    width: number;
+    height: number;
+    actors: PositionedActor[];
+    lifelines: Lifeline[];
+    messages: PositionedMessage[];
+    activations: Activation[];
+    blocks: PositionedBlock[];
+    notes: PositionedNote[];
+    /** `box … end` group backgrounds, drawn behind everything else. */
+    boxes: PositionedParticipantBox[];
+}
+
+export declare interface PositionedTitle {
+    text: string;
+    x: number;
+    y: number;
+}
+
+export declare interface PositionedXYChart {
+    width: number;
+    height: number;
+    /** Whether this is a horizontal (rotated) chart */
+    horizontal?: boolean;
+    /** Title text and position (if present) */
+    title?: PositionedTitle;
+    /** Positioned x-axis with tick marks and labels */
+    xAxis: PositionedAxis;
+    /** Positioned y-axis with tick marks and labels */
+    yAxis: PositionedAxis;
+    /** The plot area bounds (inside axes) */
+    plotArea: PlotArea;
+    /** Positioned bar groups */
+    bars: PositionedBar[];
+    /** Positioned line polylines */
+    lines: PositionedLine[];
+    /** Horizontal grid lines for readability */
+    gridLines: GridLine[];
+    /** Legend items (shown when multiple series) */
+    legend: LegendItem[];
+}
+
+/** Relationship types following UML conventions */
+export declare type RelationshipType = 'inheritance' | 'composition' | 'aggregation' | 'association' | 'dependency' | 'realization';
+
+/**
+ * Resolve a Mermaid shape name to the geometry this renderer draws.
+ * Returns `undefined` for an unrecognized name so the caller can decide
+ * whether to fall back or report it.
+ */
+export declare function resolveShapeName(name: string): NodeShape | undefined;
+
+/** Parsed sequence diagram — logical structure from mermaid text */
+export declare interface SequenceDiagram {
+    /** Ordered list of actors/participants */
+    actors: Actor[];
+    /** Messages between actors in chronological order */
+    messages: Message[];
+    /** Structural blocks (loop, alt, opt, par, critical) */
+    blocks: Block[];
+    /** Notes attached to actors */
+    notes: Note[];
+    /**
+     * Standalone `activate X` / `deactivate X` statements, in source order.
+     * The inline `+`/`-` arrow shorthand is *not* recorded here — it stays on
+     * `Message.activate` / `Message.deactivate` — but both feed the same
+     * activation stack at layout time (see layout.ts), so the two forms
+     * render identically.
+     */
+    activations: ActivationEvent[];
+    /**
+     * `box <color?> <label?> … end` participant groups, in source order. A box
+     * with no members (nothing declared inside it) is kept here but drawn by
+     * neither renderer.
+     */
+    boxes: ParticipantBox[];
+}
+
+/**
+ * Narrow a regex-captured block keyword to `Block['type']`, throwing if it
+ * somehow isn't one of the seven recognized keywords (see `isBlockType`
+ * above — unreachable via the guarding regex in practice, but this keeps
+ * the failure explicit rather than silently mistyping the value).
+ *
+ * Exported for direct unit testing (see
+ * src/__tests__/sequence-parser.test.ts) — the throw branch is unreachable
+ * through the public `parseSequenceDiagram` API (the regex that captures
+ * the value already restricts it to the seven valid keywords), so it can
+ * only be exercised by calling this function directly.
+ */
+export declare function toBlockType(value: string): Block['type'];
+
+/** Axis configuration — categorical (labels) or numeric (range) */
+export declare interface XYAxis {
+    /** Optional axis title/label */
+    title?: string;
+    /** Categorical labels (e.g., ["jan", "feb", "mar"]) — mutually exclusive with range */
+    categories?: string[];
+    /** Numeric range — mutually exclusive with categories */
+    range?: {
+        min: number;
+        max: number;
+    };
+}
+
+/** Parsed XY chart — logical structure from mermaid text */
+export declare interface XYChart {
+    /** Optional chart title */
+    title?: string;
+    /** Chart orientation: vertical (default) or horizontal */
+    horizontal: boolean;
+    /** X-axis configuration */
+    xAxis: XYAxis;
+    /** Y-axis configuration */
+    yAxis: XYAxis;
+    /** Data series (bar and/or line) */
+    series: XYChartSeries[];
+}
+
+/** A single data series (bar or line) */
+export declare interface XYChartSeries {
+    /** Series type */
+    type: 'bar' | 'line';
+    /** Data values — one per category, or evenly spaced across numeric range */
+    data: number[];
+}
+
+export { }