import { _ as GraphFormatConverter, f as Graph } from "../../types-BAEQTwK_.mjs";

//#region src/formats/mermaid/sequence.d.ts
interface SequenceNodeData {
  actorType: 'participant' | 'actor' | 'boundary' | 'control' | 'entity' | 'database' | 'collections' | 'queue';
  alias?: string;
  created?: boolean;
  destroyed?: boolean;
  notes?: Array<{
    position: 'left' | 'right' | 'over';
    text: string;
    over?: string[];
  }>;
  box?: {
    title?: string;
    color?: string;
  };
}
interface SequenceEdgeData {
  kind: 'message' | 'activation' | 'deactivation';
  stroke?: 'solid' | 'dotted';
  arrowType?: 'filled' | 'open' | 'cross' | 'async' | 'half-top' | 'half-bottom' | 'half-reverse-top' | 'half-reverse-bottom' | 'stick-half-top' | 'stick-half-bottom' | 'stick-half-reverse-top' | 'stick-half-reverse-bottom';
  bidirectional?: boolean;
  centralSource?: boolean;
  centralTarget?: boolean;
  sequenceNumber?: number;
}
/**
 * Control-flow blocks (loop/alt/par/opt/critical/break/rect).
 * Not graph topology — they describe ordering constraints.
 * Stored in `graphData.blocks` for round-trip fidelity.
 */
type SequenceBlock = {
  type: 'loop';
  label: string;
  edgeIds: string[];
} | {
  type: 'alt';
  label: string;
  branches: {
    label?: string;
    edgeIds: string[];
  }[];
} | {
  type: 'opt';
  label: string;
  edgeIds: string[];
} | {
  type: 'par';
  branches: {
    label: string;
    edgeIds: string[];
  }[];
} | {
  type: 'critical';
  label: string;
  edgeIds: string[];
  options?: {
    label: string;
    edgeIds: string[];
  }[];
} | {
  type: 'break';
  label: string;
  edgeIds: string[];
} | {
  type: 'rect';
  color: string;
  edgeIds: string[];
};
interface SequenceGraphData {
  diagramType: 'sequence';
  autonumber?: boolean;
  blocks?: SequenceBlock[];
}
type MermaidSequenceGraph = Graph<SequenceNodeData, SequenceEdgeData, SequenceGraphData>;
/**
 * Parses a Mermaid sequence diagram string into a Graph.
 *
 * @example
 * const graph = fromMermaidSequence(`
 * sequenceDiagram
 *     participant Alice
 *     participant Bob
 *     Alice->>Bob: Hello
 *     Bob-->>Alice: Hi back
 * `);
 */
declare function fromMermaidSequence(input: string): MermaidSequenceGraph;
/**
 * Converts a sequence diagram Graph to a Mermaid sequence diagram string.
 *
 * @example
 * const mermaid = toMermaidSequence(graph);
 * // "sequenceDiagram\n    participant Alice\n    ..."
 */
declare function toMermaidSequence(graph: MermaidSequenceGraph): string;
/**
 * Bidirectional converter for Mermaid sequence diagram format.
 *
 * @example
 * const graph = mermaidSequenceConverter.from(`
 * sequenceDiagram
 *     Alice->>Bob: Hello
 * `);
 * const str = mermaidSequenceConverter.to(graph);
 */
declare const mermaidSequenceConverter: GraphFormatConverter<string, SequenceNodeData, SequenceEdgeData, SequenceGraphData>;
//#endregion
//#region src/formats/mermaid/flowchart.d.ts
interface FlowchartNodeData {
  classes?: string[];
  link?: string;
  tooltip?: string;
  direction?: 'up' | 'down' | 'left' | 'right';
}
interface FlowchartEdgeData {
  stroke: 'normal' | 'dotted' | 'thick' | 'invisible';
  arrowType: 'arrow' | 'none';
  endMarker?: 'arrow' | 'circle' | 'cross';
  startMarker?: 'arrow' | 'circle' | 'cross';
  bidirectional?: boolean;
  styleIndex?: number;
}
interface FlowchartGraphData {
  diagramType: 'flowchart';
  classDefs?: Record<string, Record<string, string>>;
}
type MermaidFlowchartGraph = Graph<FlowchartNodeData, FlowchartEdgeData, FlowchartGraphData>;
/**
 * Parses a Mermaid flowchart string into a Graph.
 *
 * @example
 * const graph = fromMermaidFlowchart(`
 * flowchart TD
 *     A[Start] --> B{Decision}
 *     B -->|Yes| C[End]
 * `);
 */
declare function fromMermaidFlowchart(input: string): MermaidFlowchartGraph;
/**
 * Converts a flowchart Graph to a Mermaid flowchart string.
 *
 * @example
 * const mermaid = toMermaidFlowchart(graph);
 * // "flowchart TD\n    A[Start] --> B{Decision}\n    ..."
 */
declare function toMermaidFlowchart(graph: MermaidFlowchartGraph): string;
/**
 * Bidirectional converter for Mermaid flowchart format.
 *
 * @example
 * const graph = mermaidFlowchartConverter.from(`
 * flowchart TD
 *     A --> B
 * `);
 * const str = mermaidFlowchartConverter.to(graph);
 */
declare const mermaidFlowchartConverter: GraphFormatConverter<string, FlowchartNodeData, FlowchartEdgeData, FlowchartGraphData>;
//#endregion
//#region src/formats/mermaid/state.d.ts
interface StateNodeData {
  description?: string;
  stateType?: 'choice' | 'fork' | 'join' | 'parallel';
  notes?: Array<{
    position: 'left' | 'right';
    text: string;
    format?: 'inline' | 'block';
  }>;
  isStart?: boolean;
  isEnd?: boolean;
  classes?: string[];
  direction?: 'up' | 'down' | 'left' | 'right';
}
interface StateEdgeData {}
interface StateGraphData {
  diagramType: 'stateDiagram';
  classDefs?: Record<string, Record<string, string>>;
}
type MermaidStateGraph = Graph<StateNodeData, StateEdgeData, StateGraphData>;
/**
 * Parses a Mermaid state diagram string into a Graph.
 *
 * @example
 * const graph = fromMermaidState(`
 * stateDiagram-v2
 *     [*] --> Idle
 *     Idle --> Running : start
 *     Running --> [*]
 * `);
 */
declare function fromMermaidState(input: string): MermaidStateGraph;
/**
 * Converts a state diagram Graph to a Mermaid state diagram string.
 *
 * @example
 * const mermaid = toMermaidState(graph);
 * // "stateDiagram-v2\n    [*] --> Idle\n    ..."
 */
declare function toMermaidState(graph: MermaidStateGraph): string;
/**
 * Bidirectional converter for Mermaid state diagram format.
 *
 * @example
 * const graph = mermaidStateConverter.from(`
 * stateDiagram-v2
 *     [*] --> Active
 * `);
 * const str = mermaidStateConverter.to(graph);
 */
declare const mermaidStateConverter: GraphFormatConverter<string, StateNodeData, StateEdgeData, StateGraphData>;
//#endregion
//#region src/formats/mermaid/class-diagram.d.ts
interface ClassNodeData {
  members?: Array<{
    visibility: '+' | '-' | '#' | '~';
    name: string;
    type?: string;
    isMethod: boolean;
  }>;
  annotation?: string;
  genericType?: string;
}
interface ClassEdgeData {
  relationType: 'inheritance' | 'composition' | 'aggregation' | 'association' | 'dependency' | 'realization' | 'link' | 'dashed';
  sourceCardinality?: string;
  targetCardinality?: string;
}
interface ClassGraphData {
  diagramType: 'classDiagram';
}
type MermaidClassGraph = Graph<ClassNodeData, ClassEdgeData, ClassGraphData>;
/**
 * Parses a Mermaid class diagram string into a Graph.
 *
 * @example
 * const graph = fromMermaidClass(`
 * classDiagram
 *     class Animal {
 *         +String name
 *         +eat() void
 *     }
 *     Animal <|-- Dog
 * `);
 */
declare function fromMermaidClass(input: string): MermaidClassGraph;
/**
 * Converts a class diagram Graph to a Mermaid class diagram string.
 *
 * @example
 * const mermaid = toMermaidClass(graph);
 * // "classDiagram\n    class Animal {\n    ..."
 */
declare function toMermaidClass(graph: MermaidClassGraph): string;
/**
 * Bidirectional converter for Mermaid class diagram format.
 *
 * @example
 * const graph = mermaidClassConverter.from(`
 * classDiagram
 *     Animal <|-- Dog
 * `);
 * const str = mermaidClassConverter.to(graph);
 */
declare const mermaidClassConverter: GraphFormatConverter<string, ClassNodeData, ClassEdgeData, ClassGraphData>;
//#endregion
//#region src/formats/mermaid/er-diagram.d.ts
interface ERNodeData {
  attributes?: Array<{
    type: string;
    name: string;
    key?: 'PK' | 'FK' | 'UK';
    comment?: string;
  }>;
}
interface EREdgeData {
  sourceCardinality: 'one' | 'zero-or-one' | 'zero-or-more' | 'one-or-more';
  targetCardinality: 'one' | 'zero-or-one' | 'zero-or-more' | 'one-or-more';
  identifying: boolean;
}
interface ERGraphData {
  diagramType: 'erDiagram';
}
type MermaidERGraph = Graph<ERNodeData, EREdgeData, ERGraphData>;
/**
 * Parses a Mermaid ER diagram string into a Graph.
 *
 * @example
 * const graph = fromMermaidER(`
 * erDiagram
 *     CUSTOMER ||--o{ ORDER : places
 *     ORDER ||--|{ LINE_ITEM : contains
 * `);
 */
declare function fromMermaidER(input: string): MermaidERGraph;
/**
 * Converts an ER diagram Graph to a Mermaid ER diagram string.
 *
 * @example
 * const mermaid = toMermaidER(graph);
 * // "erDiagram\n    CUSTOMER ||--o{ ORDER : \"places\"\n    ..."
 */
declare function toMermaidER(graph: MermaidERGraph): string;
/**
 * Bidirectional converter for Mermaid ER diagram format.
 *
 * @example
 * const graph = mermaidERConverter.from(`
 * erDiagram
 *     CUSTOMER ||--o{ ORDER : places
 * `);
 * const str = mermaidERConverter.to(graph);
 */
declare const mermaidERConverter: GraphFormatConverter<string, ERNodeData, EREdgeData, ERGraphData>;
//#endregion
//#region src/formats/mermaid/mindmap.d.ts
interface MindmapNodeData {
  icon?: string;
}
interface MindmapEdgeData {}
interface MindmapGraphData {
  diagramType: 'mindmap';
}
type MermaidMindmapGraph = Graph<MindmapNodeData, MindmapEdgeData, MindmapGraphData>;
/**
 * Parses a Mermaid mindmap string into a Graph.
 *
 * @example
 * const graph = fromMermaidMindmap(`
 * mindmap
 *   Root
 *     Child A
 *       Grandchild
 *     Child B
 * `);
 */
declare function fromMermaidMindmap(input: string): MermaidMindmapGraph;
/**
 * Converts a mindmap Graph to a Mermaid mindmap string.
 *
 * @example
 * const mermaid = toMermaidMindmap(graph);
 * // "mindmap\n  Root\n    Child A\n    ..."
 */
declare function toMermaidMindmap(graph: MermaidMindmapGraph): string;
/**
 * Bidirectional converter for Mermaid mindmap format.
 *
 * @example
 * const graph = mermaidMindmapConverter.from(`
 * mindmap
 *   Root
 *     Branch
 * `);
 * const str = mermaidMindmapConverter.to(graph);
 */
declare const mermaidMindmapConverter: GraphFormatConverter<string, MindmapNodeData, MindmapEdgeData, MindmapGraphData>;
//#endregion
//#region src/formats/mermaid/block.d.ts
interface BlockNodeData {
  span?: number;
}
interface BlockEdgeData {}
interface BlockGraphData {
  diagramType: 'block';
  columns?: number;
}
type MermaidBlockGraph = Graph<BlockNodeData, BlockEdgeData, BlockGraphData>;
/**
 * Parses a Mermaid block diagram string into a Graph.
 *
 * @example
 * const graph = fromMermaidBlock(`
 * block-beta
 *     columns 2
 *     a["Task A"] b["Task B"]
 *     a --> b
 * `);
 */
declare function fromMermaidBlock(input: string): MermaidBlockGraph;
/**
 * Converts a block diagram Graph to a Mermaid block diagram string.
 *
 * @example
 * const mermaid = toMermaidBlock(graph);
 * // "block-beta\n    columns 2\n    a[\"Task A\"]\n    ..."
 */
declare function toMermaidBlock(graph: MermaidBlockGraph): string;
/**
 * Bidirectional converter for Mermaid block diagram format.
 *
 * @example
 * const graph = mermaidBlockConverter.from(`
 * block-beta
 *     columns 2
 *     a b
 * `);
 * const str = mermaidBlockConverter.to(graph);
 */
declare const mermaidBlockConverter: GraphFormatConverter<string, BlockNodeData, BlockEdgeData, BlockGraphData>;
//#endregion
//#region src/formats/mermaid/ishikawa.d.ts
interface IshikawaNodeData {
  kind: 'effect' | 'cause';
}
interface IshikawaEdgeData {}
interface IshikawaGraphData {
  diagramType: 'ishikawa';
}
type MermaidIshikawaGraph = Graph<IshikawaNodeData, IshikawaEdgeData, IshikawaGraphData>;
/**
 * Parses a Mermaid Ishikawa diagram string into a Graph.
 *
 * @example
 * const graph = fromMermaidIshikawa(`
 * ishikawa-beta
 * Problem
 *     Cause
 *         Sub-cause
 * `);
 */
declare function fromMermaidIshikawa(input: string): MermaidIshikawaGraph;
/**
 * Converts an Ishikawa Graph to a Mermaid Ishikawa diagram string.
 *
 * @example
 * const mermaid = toMermaidIshikawa(graph);
 * // "ishikawa-beta\nProblem\n    Cause"
 */
declare function toMermaidIshikawa(graph: MermaidIshikawaGraph): string;
/**
 * Bidirectional converter for Mermaid Ishikawa diagram format.
 *
 * @example
 * const graph = mermaidIshikawaConverter.from(`
 * ishikawa-beta
 * Problem
 *     Cause
 * `);
 * const str = mermaidIshikawaConverter.to(graph);
 */
declare const mermaidIshikawaConverter: GraphFormatConverter<string, IshikawaNodeData, IshikawaEdgeData, IshikawaGraphData>;
//#endregion
export { type BlockEdgeData, type BlockGraphData, type BlockNodeData, type ClassEdgeData, type ClassGraphData, type ClassNodeData, type EREdgeData, type ERGraphData, type ERNodeData, type FlowchartEdgeData, type FlowchartGraphData, type FlowchartNodeData, type IshikawaEdgeData, type IshikawaGraphData, type IshikawaNodeData, type MermaidBlockGraph, type MermaidClassGraph, type MermaidERGraph, type MermaidFlowchartGraph, type MermaidIshikawaGraph, type MermaidMindmapGraph, type MermaidSequenceGraph, type MermaidStateGraph, type MindmapEdgeData, type MindmapGraphData, type MindmapNodeData, type SequenceBlock, type SequenceEdgeData, type SequenceGraphData, type SequenceNodeData, type StateEdgeData, type StateGraphData, type StateNodeData, fromMermaidBlock, fromMermaidClass, fromMermaidER, fromMermaidFlowchart, fromMermaidIshikawa, fromMermaidMindmap, fromMermaidSequence, fromMermaidState, mermaidBlockConverter, mermaidClassConverter, mermaidERConverter, mermaidFlowchartConverter, mermaidIshikawaConverter, mermaidMindmapConverter, mermaidSequenceConverter, mermaidStateConverter, toMermaidBlock, toMermaidClass, toMermaidER, toMermaidFlowchart, toMermaidIshikawa, toMermaidMindmap, toMermaidSequence, toMermaidState };