import * as _xyflow_react from '@xyflow/react';
import { Node, Connection, MarkerType, Edge, NodeTypes, EdgeTypes, NodeProps, EdgeProps, ReactFlowJsonObject } from '@xyflow/react';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as react from 'react';
import react__default from 'react';
import dagre from 'dagre';

/**
 * EventCatalog resource mode
 */
type EventCatalogResource = {
    mode: "simple" | "full";
    style?: string;
    collection?: string;
    filePath?: string;
    id?: string;
    /** Marks the resource represented by the current visualizer page. */
    isFocused?: boolean;
};
/**
 * Message types (Events, Commands, Queries)
 */
type Message = {
    name: string;
    version: string;
    summary: string;
    owners?: string[];
    producers?: string[];
    consumers?: string[];
    deprecated?: boolean;
    draft?: boolean;
    schema?: string;
    notes?: Note[];
    /** HTTP method (e.g. GET, POST, PUT, DELETE) */
    method?: string;
    /** API path (e.g. /pets, /users/:id) */
    path?: string;
    /** HTTP status codes (e.g. [200, 401, 500]) */
    statusCodes?: number[];
    styles?: {
        icon?: string;
        node?: {
            color?: string;
            label?: string;
        };
    };
};
/**
 * Note attached to a resource
 */
type Note = {
    content: string;
    author?: string;
    priority?: string;
};
/**
 * Service type
 */
type Service = {
    name: string;
    version: string;
    summary: string;
    owners?: string[];
    sends?: string[];
    receives?: string[];
    deprecated?: boolean;
    draft?: boolean;
    notes?: Note[];
    specifications?: unknown;
    externalSystem?: boolean;
    styles?: {
        icon?: string;
        node?: {
            color?: string;
            label?: string;
        };
    };
};
/**
 * Agent type
 */
type Agent$1 = {
    name: string;
    version: string;
    summary: string;
    owners?: string[];
    sends?: string[];
    receives?: string[];
    deprecated?: boolean;
    draft?: boolean;
    notes?: Note[];
    model?: {
        provider?: string;
        name?: string;
        version?: string;
    };
    tools?: Array<{
        name: string;
        type: string;
        icon?: string;
        url?: string;
        description?: string;
    }>;
    styles?: {
        icon?: string;
        node?: {
            color?: string;
            label?: string;
        };
    };
};
/**
 * Tool used by an agent
 */
type AgentTool$1 = {
    id?: string;
    name: string;
    type: string;
    icon?: string;
    url?: string;
    description?: string;
};
/**
 * Channel type
 */
type Channel = {
    name: string;
    version: string;
    summary: string;
    owners?: string[];
    parameters?: Record<string, string>;
    protocols?: string[];
    address?: string;
    deprecated?: boolean;
    draft?: boolean;
    notes?: Note[];
    /** Delivery guarantee (e.g. at-most-once, at-least-once, exactly-once) */
    deliveryGuarantee?: string;
    styles?: {
        icon?: string;
        node?: {
            color?: string;
            label?: string;
        };
    };
};
/**
 * External System type
 */
type ExternalSystem = {
    name: string;
    version: string;
    summary: string;
    notes?: Note[];
};
/**
 * Data type
 */
type Data = {
    name: string;
    version: string;
    summary: string;
    owners?: string[];
    type?: string;
    container_type?: string;
    schemas?: string[];
    deprecated?: boolean;
    draft?: boolean;
    notes?: Note[];
    styles?: {
        icon?: string;
        node?: {
            color?: string;
            label?: string;
        };
    };
};
/**
 * View type
 */
type View = {
    name: string;
    version: string;
    summary: string;
    owners?: string[];
    screenshot?: string;
    notes?: Note[];
};
/**
 * Generic node data structure - framework agnostic
 */
interface BaseNodeData {
    id: string;
    version?: string;
    name?: string;
    summary?: string;
    markdown?: string;
    badges?: Array<{
        content: string;
        textColor?: string;
        backgroundColor?: string;
    }>;
    group?: {
        id: string;
        name: string;
        type: string;
    };
    [key: string]: any;
}
/**
 * Node types supported by the visualizer
 */
type NodeType = "agent" | "agents" | "agentTool" | "agent-tool" | "service" | "services" | "event" | "events" | "command" | "commands" | "query" | "queries" | "domain" | "domains" | "flow" | "flows" | "channel" | "channels" | "entity" | "entities" | "step" | "user" | "custom" | "externalSystem" | "external-system" | "data" | "container" | "view" | "actor" | "data-product" | "data-products" | "note";
/**
 * Edge types supported by the visualizer
 */
type EdgeType = "default" | "animated" | "multiline" | "flow-edge";
/**
 * Callback types for framework integration
 */
interface VisualizerCallbacks {
    /** Called when a node is clicked */
    onNodeClick?: (node: Node<BaseNodeData>) => void;
    /** Called to build a URL for a node (for linking) */
    onBuildNodeUrl?: (node: Node<BaseNodeData>) => string;
    /** Called when navigation should occur */
    onNavigate?: (url: string) => void;
}
/**
 * Configuration for node registration
 */
interface NodeConfiguration {
    type: string;
    icon: React.ComponentType;
    color: string;
    targetCanConnectTo?: string[];
    sourceCanConnectTo?: string[];
    validateConnection?: (connection: Connection) => boolean;
    getEdgeOptions?: (connection: Connection) => {
        label: string;
        markerEnd: {
            type: MarkerType;
            color: string;
        };
    };
    defaultData?: any;
    editor?: {
        title: string;
        subtitle: string;
        schema: any;
    };
}
/**
 * Registered node type
 */
type RegisteredNode = {
    type: string;
    category: string;
    component: React.ComponentType<any>;
    configuration: NodeConfiguration;
};
/**
 * Node category
 */
type NodeCategory = {
    type: string;
    label: string;
    icon: React.ComponentType;
};
/**
 * Context menu item for node right-click menus
 */
type ContextMenuItem = {
    label: string;
    href: string;
    download?: string;
    external?: boolean;
    separator?: boolean;
};
/**
 * Visualizer mode
 */
type VisualizerMode = "full" | "simple";
/**
 * Link to other visualizer views
 */
interface VisualizerLink {
    label: string;
    url: string;
}
/**
 * DSL Graph types – used by the playground and any consumer that wants
 * to hand a high-level graph to the visualiser for automatic layout.
 */
interface GraphNode {
    id: string;
    type: "domain" | "agent" | "agent-tool" | "agentTool" | "service" | "event" | "command" | "query" | "channel" | "entity" | "container" | "data" | "data-product" | "flow" | "actor" | "external-system" | "step" | "user" | "team" | "diagram";
    label: string;
    parentId?: string;
    metadata: Record<string, unknown>;
}
type GraphEdgeType = "sends" | "receives" | "publishes" | "subscribes" | "writes-to" | "reads-from" | "reads-writes" | "contains" | "owns" | "member-of" | "routes-to" | "calls" | "flow-step";
interface GraphEdge {
    id: string;
    source: string;
    target: string;
    type: GraphEdgeType;
    label?: string;
}
interface DslGraph {
    nodes: GraphNode[];
    edges: GraphEdge[];
    visualizers?: string[];
    activeVisualizer?: string;
    title?: string;
    empty?: boolean;
    options?: {
        legend?: boolean;
        search?: boolean;
        toolbar?: boolean;
        focusMode?: boolean;
        animated?: boolean;
        style?: string;
    };
}

interface NodeGraphProps {
    id: string;
    title?: string;
    href?: string;
    hrefLabel?: string;
    nodes?: Node[];
    edges?: Edge[];
    graph?: DslGraph;
    linkTo?: "docs" | "visualiser";
    includeKey?: boolean;
    footerLabel?: string;
    linksToVisualiser?: boolean;
    links?: {
        label: string;
        url: string;
    }[];
    mode?: "full" | "simple";
    portalId?: string;
    showFlowWalkthrough?: boolean;
    showSearch?: boolean;
    zoomOnScroll?: boolean;
    designId?: string;
    isChatEnabled?: boolean;
    maxTextSize?: number;
    isDevMode?: boolean;
    resourceKey?: string;
    /** Controls whether message flow animation is enabled. When set, overrides URL params and localStorage. */
    animated?: boolean;
    /**
     * When true, message-flow animation is unsupported for this graph: it is forced
     * off (ignoring the `animated` prop, URL params and localStorage) and the
     * "Simulate Messages" toggle is hidden. Used by graphs that aren't message
     * flows, e.g. the System Diagram.
     */
    disableMessageAnimation?: boolean;
    /** When set, the graph will zoom to this node id. */
    focusNodeId?: string;
    /** Optional token to force repeated focus for the same node id. */
    focusRequestId?: number;
    /** Optional token to trigger fit-to-screen behavior. */
    fitRequestId?: number;
    onNodeClick?: (node: Node) => void;
    onBuildUrl?: (path: string) => string;
    onNavigate?: (url: string) => void;
    onSaveLayout?: (resourceKey: string, positions: Record<string, {
        x: number;
        y: number;
    }>) => Promise<boolean>;
    onResetLayout?: (resourceKey: string) => Promise<boolean>;
}
declare const NodeGraph: ({ id, nodes: nodesProp, edges: edgesProp, graph, title: titleProp, href, linkTo, hrefLabel, includeKey: includeKeyProp, footerLabel, linksToVisualiser, links, mode, portalId, showFlowWalkthrough, showSearch: showSearchProp, zoomOnScroll, designId, isChatEnabled, maxTextSize, isDevMode, resourceKey, animated: animatedProp, focusNodeId, focusRequestId, fitRequestId, onNodeClick, onBuildUrl, onNavigate, onSaveLayout, onResetLayout, }: NodeGraphProps) => react_jsx_runtime.JSX.Element | null;

interface MermaidViewProps {
    nodes: Node[];
    edges: Edge[];
    maxTextSize?: number;
}
declare const MermaidView: ({ nodes, edges, maxTextSize, }: MermaidViewProps) => react_jsx_runtime.JSX.Element;

interface ResourceData {
    id?: string;
    name?: string;
    version?: string;
}
type MessageData = ResourceData;
type ServiceData = ResourceData;
type AgentData = ResourceData;
type AgentToolData$1 = ResourceData;
type DomainData = ResourceData;
type EntityData = ResourceData;
interface NodeDataContent extends Record<string, unknown> {
    message?: {
        data?: MessageData;
    } & MessageData;
    service?: {
        data?: ServiceData;
    } & ServiceData;
    agent?: {
        data?: AgentData;
    } & AgentData;
    agentTool?: {
        data?: AgentToolData$1;
    } & AgentToolData$1;
    domain?: {
        data?: DomainData;
    } & DomainData;
    system?: {
        data?: ResourceData;
    } & ResourceData;
    entity?: {
        data?: EntityData;
    } & EntityData;
    channel?: {
        data?: ResourceData;
    } & ResourceData;
    dataProduct?: {
        data?: ResourceData;
    } & ResourceData;
    data?: ResourceData;
    name?: string;
    version?: string;
    groupName?: string;
    messages?: Array<{
        message?: {
            collection?: string;
            data?: MessageData & {
                id?: string;
            };
        };
    }>;
}
type CustomNode$1 = Node<NodeDataContent>;
interface VisualiserSearchProps {
    nodes: CustomNode$1[];
    onNodeSelect: (node: CustomNode$1) => void;
    onClear: () => void;
    onPaneClick?: () => void;
}
interface VisualiserSearchRef {
    hideSuggestions: () => void;
}
declare const VisualiserSearch: react.NamedExoticComponent<VisualiserSearchProps & react.RefAttributes<VisualiserSearchRef>>;

interface NodeData {
    label?: string;
    summary?: string;
    step?: {
        title?: string;
        summary?: string;
    };
    service?: {
        name?: string;
        summary?: string;
        data?: {
            name?: string;
            summary?: string;
        };
    };
    message?: {
        name?: string;
        summary?: string;
        data?: {
            name?: string;
            summary?: string;
        };
    };
    flow?: {
        data?: {
            name?: string;
        };
    };
    custom?: {
        title?: string;
        label?: string;
        summary?: string;
    };
    actor?: {
        label?: string;
    };
    externalSystem?: {
        label?: string;
    };
}
interface CustomNode {
    id: string;
    data: NodeData;
}
interface StepWalkthroughProps {
    nodes: CustomNode[];
    edges: Edge[];
    isFlowVisualization: boolean;
    onStepChange: (nodeId: string | null, highlightPaths?: string[], shouldZoomOut?: boolean) => void;
    mode?: "full" | "simple";
}
declare const _default$w: react__default.NamedExoticComponent<StepWalkthroughProps>;

interface FocusModeModalProps {
    isOpen: boolean;
    onClose: () => void;
    initialNodeId: string | null;
    nodes: Node[];
    edges: Edge[];
    nodeTypes: NodeTypes;
    edgeTypes: EdgeTypes;
}
declare const FocusModeModal: react__default.FC<FocusModeModalProps>;

interface NodeContextMenuProps {
    items: ContextMenuItem[];
    children: React.ReactNode;
}
declare const _default$v: react.NamedExoticComponent<NodeContextMenuProps>;

type MessageGroupNodeData = {
    mode?: string;
    groupName: string;
    direction: "sends" | "receives";
    messageCount: number;
    messageTypes: string[];
    messages: Array<{
        message: any;
        channels: any[];
    }>;
    service: {
        id: string;
        version: string;
    };
};
type MessageGroupNode = Node<MessageGroupNodeData, "messageGroup">;
declare const _default$u: react.NamedExoticComponent<MessageGroupNode>;

type MessageGroupExpandedNodeData = {
    groupName: string;
    direction: "sends" | "receives";
    messageCount: number;
    onCollapse?: string;
};
declare const _default$t: react.NamedExoticComponent<{
    data: MessageGroupExpandedNodeData;
}>;

type DataProductNodeData = EventCatalogResource & {
    dataProduct: {
        id: string;
        version: string;
        name: string;
        summary?: string;
        inputs?: any[];
        outputs?: any[];
        owners?: any[];
        deprecated?: boolean;
        draft?: boolean;
        notes?: Note[];
        styles?: {
            icon?: string;
            node?: {
                color?: string;
                label?: string;
            };
        };
    };
};
type DataProductNode = Node<DataProductNodeData, "data-product">;
declare const _default$s: react.NamedExoticComponent<DataProductNode>;

type FlowExpandedNodeData = {
    flowName?: string;
    version?: string;
};
declare const _default$r: react.NamedExoticComponent<{
    data: FlowExpandedNodeData;
}>;

type FieldNodeData = {
    name: string;
    type?: string;
    mode?: "simple" | "full";
};
type FieldNode = Node<FieldNodeData, "field">;
declare const _default$q: react.NamedExoticComponent<FieldNode>;

declare const _default$p: NodeConfiguration;

type ActorNodeData = EventCatalogResource & {
    name: string;
    summary: string;
    deprecated?: boolean;
    draft?: boolean;
    notes?: Note[];
};
type ActorNode = Node<ActorNodeData, "actor">;
declare const _default$o: react.NamedExoticComponent<ActorNode>;

declare const _default$n: NodeConfiguration;

type ViewNodeData = EventCatalogResource & {
    view: View;
};
type ViewNode = Node<ViewNodeData, "view">;

type DataNodeData = EventCatalogResource & {
    data: Data;
};
type DataNode = Node<DataNodeData, "data">;

declare const _default$m: NodeConfiguration;

type ExternalSystemNodeData = EventCatalogResource & {
    externalSystem: ExternalSystem & {
        deprecated?: boolean;
        draft?: boolean;
    };
};
type ExternalSystemNode = Node<ExternalSystemNodeData, "external-system">;

declare const _default$l: NodeConfiguration;

type NoteNodeData = {
    id: string;
    text: string;
    color?: string;
    readOnly?: boolean;
};
type NoteNode = Node<NoteNodeData, "note">;
interface NoteNodeProps extends NoteNode {
    onTextChange?: (id: string, text: string) => void;
    onColorChange?: (id: string, color: string) => void;
    showResizer?: boolean;
    readOnly?: boolean;
}
declare const _default$k: react__default.NamedExoticComponent<NoteNodeProps>;

type ChannelNodeData = EventCatalogResource & {
    channel: Channel;
};
type ChannelNode = Node<ChannelNodeData, "channel">;

type AgentToolData = EventCatalogResource & {
    agentTool: {
        id?: string;
        name: string;
        type: string;
        icon?: string;
        url?: string;
        description?: string;
    };
};
type AgentToolNode = Node<AgentToolData, "agentTool">;
declare function AgentTool(props: AgentToolNode): react_jsx_runtime.JSX.Element;
declare const _default$j: react.MemoExoticComponent<typeof AgentTool>;

type AgentNodeData = EventCatalogResource & {
    agent: {
        id: string;
        version: string;
        name: string;
        summary?: string;
        owners?: any[];
        deprecated?: boolean;
        draft?: boolean;
        notes?: Note[];
        model?: {
            provider?: string;
            name?: string;
            version?: string;
        };
        styles?: {
            icon?: string;
            node?: {
                color?: string;
                label?: string;
            };
        };
    };
};
type AgentNode = Node<AgentNodeData, "agent">;
declare function Agent(props: AgentNode): react_jsx_runtime.JSX.Element;
declare const _default$i: react.MemoExoticComponent<typeof Agent>;

type ServiceNodeData = EventCatalogResource & {
    service: Service;
};
type ServiceNode = Node<ServiceNodeData, "service">;
declare const _default$h: react.NamedExoticComponent<ServiceNode>;

type QueryNodeData = EventCatalogResource & {
    message: Message;
};
type QueryNode = Node<QueryNodeData, "query">;
declare const _default$g: react.NamedExoticComponent<QueryNode>;

type CommandNodeData = EventCatalogResource & {
    message: Message;
};
type CommandNode = Node<CommandNodeData, "command">;
declare const _default$f: react.NamedExoticComponent<CommandNode>;

type MessageNodeData = EventCatalogResource & {
    message: Message;
};
type EventNode = Node<MessageNodeData, "event">;
declare const _default$e: react.NamedExoticComponent<EventNode>;

declare const _default$d: NodeConfiguration;

declare const NotesIndicator: react.NamedExoticComponent<{
    notes: Note[];
    resourceName?: string;
}>;

/**
 * Normalise owners which may arrive as string[] or {id:string}[] from Astro.
 */
declare function normalizeOwners(raw: any[] | undefined): string[];
/**
 * Compact owner indicator for the bottom of a node card.
 * Shows a small icon + primary owner name + overflow pill.
 *
 * @param accentColor - Tailwind color class for the pill, e.g. "bg-pink-400"
 * @param borderColor - CSS color string for the top border
 * @param iconClass   - Tailwind text color for the icon, e.g. "text-pink-300"
 */
declare const OwnerIndicator: react.NamedExoticComponent<{
    owners: string[];
    accentColor?: string;
    borderColor?: string;
    iconClass?: string;
}>;

declare const ENTITY_TARGET_HANDLE_ID = "__eventcatalog-entity-target";
interface EntityProperty {
    name: string;
    type: string;
    required?: boolean;
    description?: string;
    references?: string;
    referencesIdentifier?: string;
    referenceTarget?: "entity";
    relationType?: string;
    enum?: string[];
    properties?: EntityProperty[];
    items?: {
        type: string;
        properties?: EntityProperty[];
    };
}
declare const getPropertyTypeLabel: (property: any) => any;
declare const getNestedEntityProperties: (property: EntityProperty) => EntityProperty[];
declare const _default$c: react.NamedExoticComponent<any>;

declare const _default$b: react.NamedExoticComponent<any>;

declare const _default$a: react.NamedExoticComponent<any>;

/**
 * A system rendered on the System Diagram.
 *
 * Styled to match the other resource nodes (e.g. the service node): a rounded,
 * bordered card with a floating type badge + icon on the top-left border.
 * Left-clicking the node navigates to the system's architecture map.
 * Right-click (handled by the NodeGraph context-menu wrapper) offers docs / map / context.
 */
declare const _default$9: react.NamedExoticComponent<any>;

/**
 * An actor (person/role) on the System Diagram.
 *
 * Deliberately styled differently from the boxy resource nodes: a soft, pill-ish
 * card with the actor icon in a circular badge centered at the top and the actor
 * name centered below. This reads as "a person", not "a system", at a glance.
 */
declare const _default$8: react.NamedExoticComponent<any>;

declare const _default$7: react.NamedExoticComponent<NodeProps>;

declare const _default$6: react.NamedExoticComponent<any>;

declare const _default$5: react.NamedExoticComponent<NodeProps>;

declare const _default$4: react.NamedExoticComponent<any>;

declare const _default$3: react.NamedExoticComponent<any>;

declare const _default$2: react.NamedExoticComponent<any>;

declare const SERVICE: string[];
declare const AGENT: string[];
declare const AGENT_TOOL: string[];
declare const EVENT: string[];
declare const QUERY: string[];
declare const COMMAND: string[];
declare const CHANNEL: string[];
declare const ACTOR: string[];
declare const DATA: string[];
declare const VIEW: string[];
declare const MESSAGE: string[];

declare const nodeComponents: {
    event: react.NamedExoticComponent<EventNode>;
    command: react.NamedExoticComponent<CommandNode>;
    query: react.NamedExoticComponent<QueryNode>;
    service: react.NamedExoticComponent<ServiceNode>;
    agent: react.MemoExoticComponent<(props: AgentNode) => react_jsx_runtime.JSX.Element>;
    agentTool: react.MemoExoticComponent<(props: AgentToolNode) => react_jsx_runtime.JSX.Element>;
    "agent-tool": react.MemoExoticComponent<(props: AgentToolNode) => react_jsx_runtime.JSX.Element>;
    channel: react.NamedExoticComponent<ChannelNode>;
    note: react.NamedExoticComponent<NoteNodeProps>;
    externalSystem: react.NamedExoticComponent<ExternalSystemNode>;
    data: react.NamedExoticComponent<DataNode>;
    view: react.NamedExoticComponent<ViewNode>;
    actor: react.NamedExoticComponent<ActorNode>;
    field: react.NamedExoticComponent<FieldNode>;
    custom: react.NamedExoticComponent<any>;
    domain: react.NamedExoticComponent<any>;
    system: react.NamedExoticComponent<any>;
    "context-actor": react.NamedExoticComponent<any>;
    "system-group": react.NamedExoticComponent<_xyflow_react.NodeProps>;
    entity: react.NamedExoticComponent<any>;
    flow: react.NamedExoticComponent<any>;
    flowExpanded: react.NamedExoticComponent<{
        data: FlowExpandedNodeData;
    }>;
    group: react.NamedExoticComponent<_xyflow_react.NodeProps>;
    step: react.NamedExoticComponent<any>;
    user: react.NamedExoticComponent<any>;
    dataProduct: react.NamedExoticComponent<DataProductNode>;
    externalSystem2: react.NamedExoticComponent<any>;
    messageGroup: react.NamedExoticComponent<MessageGroupNode>;
    messageGroupExpanded: react.NamedExoticComponent<{
        data: MessageGroupExpandedNodeData;
    }>;
};
declare const nodeConfigs: Record<string, NodeConfiguration>;

interface EdgeData {
    message?: {
        collection?: string;
    };
    opacity?: number;
    animated?: boolean;
}
interface CustomEdgeProps extends Omit<EdgeProps, "data"> {
    data?: EdgeData;
}
declare const _default$1: react.NamedExoticComponent<CustomEdgeProps>;

declare const AnimatedMessageEdge: react.MemoExoticComponent<({ id, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, data, label, markerEnd, markerStart, }: any) => react_jsx_runtime.JSX.Element>;

declare const _default: react.NamedExoticComponent<EdgeProps>;

declare function LabelledDefaultEdge(props: EdgeProps): react_jsx_runtime.JSX.Element;
declare function LabelledSmoothStepEdge(props: EdgeProps): react_jsx_runtime.JSX.Element;
declare function LabelledStepEdge(props: EdgeProps): react_jsx_runtime.JSX.Element;

declare const edgeTypes: {
    animated: react.MemoExoticComponent<({ id, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, data, label, markerEnd, markerStart, }: any) => react_jsx_runtime.JSX.Element>;
    "flow-edge": react.NamedExoticComponent<CustomEdgeProps>;
    multiline: react.NamedExoticComponent<_xyflow_react.EdgeProps>;
    default: typeof LabelledDefaultEdge;
    smoothstep: typeof LabelledSmoothStepEdge;
    step: typeof LabelledStepEdge;
};

/**
 * Mermaid Export Utility
 * Converts React Flow nodes and edges to Mermaid flowchart syntax
 */
interface MermaidExportOptions {
    /** Include class definitions for styling */
    includeStyles?: boolean;
    /** Direction of the flowchart: LR (left-right), TB (top-bottom), etc. */
    direction?: "LR" | "TB" | "RL" | "BT";
}
/**
 * Convert React Flow nodes and edges to Mermaid flowchart syntax
 */
declare function convertToMermaid(nodes: Node[], edges: Edge[], options?: MermaidExportOptions): string;

declare const exportNodeGraphForStudio: (data: ReactFlowJsonObject) => ReactFlowJsonObject;

interface BaseCollectionData {
    id: string;
    version: string;
}
interface CollectionItem {
    collection: string;
    data: BaseCollectionData;
}
interface MessageCollectionItem extends CollectionItem {
    collection: "commands" | "events" | "queries";
}
declare const generateIdForNode: (node: CollectionItem) => string;
declare const generateIdForNodes: (nodes: any) => any;
declare const generatedIdForEdge: (source: CollectionItem, target: CollectionItem) => string;
declare const getColorFromString: (id: string) => string;
declare const getEdgeLabelForServiceAsTarget: (data: MessageCollectionItem) => "invokes" | "publishes \nevent" | "requests" | "sends to";
declare const getEdgeLabelForMessageAsSource: (data: MessageCollectionItem, throughChannel?: boolean) => "sends to" | "accepts" | "subscribed to" | "subscribed by";
declare const calculatedNodes: (flow: dagre.graphlib.Graph, nodes: Node[]) => any[];
declare const createDagreGraph: ({ ranksep, nodesep, ...rest }: any) => dagre.graphlib.Graph<{}>;
/**
 * network-simplex produces the nicest layered layout but is O(V·E) and hangs on
 * large architecture maps. tight-tree keeps the same LR layering with far less
 * work. Callers can still force a ranker via createDagreGraph({ ranker }).
 */
declare const LARGE_GRAPH_NODE_THRESHOLD = 80;
declare const LARGE_GRAPH_EDGE_THRESHOLD = 200;
declare const LARGE_GRAPH_RANKER = "tight-tree";
declare const selectDagreRanker: (nodeCount: number, edgeCount: number, explicitRanker?: string) => string | undefined;
declare const layoutDagreGraph: (flow: dagre.graphlib.Graph) => void;
declare const createEdge: (edgeOptions: Edge) => Edge;
declare const createNode: (values: Node) => Node;
type DagreGraph = any;
declare const getNodesAndEdgesFromDagre: ({ nodes, edges, defaultFlow, }: {
    nodes: Node[];
    edges: Edge[];
    defaultFlow?: DagreGraph;
}) => {
    nodes: any[];
    edges: Edge[];
};

declare function buildNodeData(node: GraphNode, style?: string): Record<string, unknown>;
declare function layoutGraph(nodes: GraphNode[], edges: GraphEdge[], options?: {
    rankdir?: string;
    nodesep?: number;
    ranksep?: number;
    edgesep?: number;
}, style?: string): {
    nodes: Node[];
    edges: Edge[];
};

export { ACTOR, AGENT, AGENT_TOOL, _default$o as Actor, type ActorNode, type Agent$1 as Agent, _default$i as AgentNode, type AgentTool$1 as AgentTool, _default$j as AgentToolNode, type AgentToolNode as AgentToolNodeType, AnimatedMessageEdge, type BaseNodeData, CHANNEL, COMMAND, type Channel, type ChannelNode, _default$f as Command, type CommandNode, _default$8 as ContextActorNode, type ContextMenuItem, _default$b as CustomNode, DATA, type Data, type DataNode, _default$s as DataProductNode, _default$a as DomainNode, type DslGraph, ENTITY_TARGET_HANDLE_ID, EVENT, type EdgeType, _default$c as EntityNode, type EntityProperty, _default$e as Event, type EventCatalogResource, type EventNode, type ExternalSystem, _default$2 as ExternalSystem2Node, type ExternalSystemNode, _default$q as Field, type FieldNode as FieldNodeType, _default$1 as FlowEdge, _default$r as FlowExpandedNode, _default$6 as FlowNode, FocusModeModal, type GraphEdge, type GraphEdgeType, type GraphNode, _default$5 as GroupNode, LARGE_GRAPH_EDGE_THRESHOLD, LARGE_GRAPH_NODE_THRESHOLD, LARGE_GRAPH_RANKER, LabelledDefaultEdge, LabelledSmoothStepEdge, LabelledStepEdge, MESSAGE, type MermaidExportOptions, MermaidView, type Message, _default$t as MessageGroupExpandedNode, type MessageGroupExpandedNodeData, _default$u as MessageGroupNode, type MessageGroupNodeData, type MessageGroupNode as MessageGroupNodeType, _default as MultilineEdgeLabel, type NodeCategory, type NodeConfiguration, _default$v as NodeContextMenu, NodeGraph, type NodeGraphProps, type NodeType, _default$k as Note, type NoteNode, NotesIndicator, OwnerIndicator, QUERY, _default$g as Query, type QueryNode, type RegisteredNode, SERVICE, _default$h as Service, type ServiceNode, type Service as ServiceType, _default$4 as StepNode, _default$w as StepWalkthrough, _default$7 as SystemGroupNode, _default$9 as SystemNode, _default$3 as UserNode, VIEW, type View, type ViewNode, VisualiserSearch, type VisualizerCallbacks, type VisualizerLink, type VisualizerMode, _default$n as actorConfig, buildNodeData, calculatedNodes, convertToMermaid, createDagreGraph, createEdge, createNode, _default$m as dataNodeConfig, edgeTypes, _default$d as eventConfig, exportNodeGraphForStudio, _default$l as externalSystemConfig, _default$p as fieldConfig, generateIdForNode, generateIdForNodes, generatedIdForEdge, getColorFromString, getEdgeLabelForMessageAsSource, getEdgeLabelForServiceAsTarget, getNestedEntityProperties, getNodesAndEdgesFromDagre, getPropertyTypeLabel, layoutDagreGraph, layoutGraph, nodeComponents, nodeConfigs, normalizeOwners, selectDagreRanker };