import type { App } from '../App';
import type { Node } from '../Node';
import type { Group } from '../shapes/Group';
import type { Obstacle } from './types';
import { type RouteStyle } from './router';
export type ArrowStyle = 'filled' | 'open' | 'hollow' | 'diamond' | 'diamondHollow' | 'none';
export interface ConnectorOptions {
    style?: RouteStyle;
    obstacles?: Obstacle[];
    parent?: Group;
    /** When set with parent, rebuild obstacles in parent-local space (drag-safe). */
    obstacleNodes?: Node[];
    /** Manual bend points in parent-local space (double-click on wire). */
    waypoints?: Array<{
        x: number;
        y: number;
    }>;
    stroke?: string;
    strokeWidth?: number;
    glowColor?: string;
    /** When false, skip the soft under-glow (cleaner for dense graphs). Default true. */
    glow?: boolean;
    arrowEnd?: ArrowStyle;
    arrowStart?: ArrowStyle;
    label?: string;
    labelColor?: string;
    /**
     * Fraction along the path (0..1) for the label. Default ~0.38 keeps labels
     * near the source so they stay visible (not under the target node).
     */
    labelT?: number;
    /** Perpendicular offset (px) from the path for the label (avoids stacked labels). */
    labelOffset?: number;
    dash?: number[];
    edgeId?: string;
    fromId?: string;
    toId?: string;
    cornerRadius?: number;
    /** 0..1 fan position on the source card side (0.5 = mid). */
    fromAlong?: number;
    /** 0..1 fan position on the target card side (0.5 = mid). */
    toAlong?: number;
    /** Precomputed anchors (from fan planner); skips getConnectorAnchors. */
    anchors?: {
        x1: number;
        y1: number;
        x2: number;
        y2: number;
    };
    /** Shift orthogonal mid-rails so parallel wires stay visually separate. */
    railOffset?: number;
}
/** Angle of segment from (x1,y1) to (x2,y2) in radians */
export declare function segmentAngle(x1: number, y1: number, x2: number, y2: number): number;
/** Sleek filled arrowhead — wider base so it reads clearly on dark themes. */
export declare function arrowHeadPoints(tipX: number, tipY: number, angle: number, size?: number): number[];
/** Open (V-shaped) arrow for associations */
export declare function openArrowPoints(tipX: number, tipY: number, angle: number, size?: number): number[];
/** UML composition / aggregation diamond */
export declare function diamondPoints(tipX: number, tipY: number, angle: number, size?: number): number[];
/** Shorten terminal segment so arrowhead does not overlap stroke */
export declare function shortenPathEnd(points: number[], trim: number): number[];
/** Midpoint along polyline by arc length */
export declare function pathMidpoint(points: number[]): {
    x: number;
    y: number;
};
/**
 * Point at fraction `t` (0..1) along polyline arc length, plus unit tangent.
 * Used to park edge labels near the source so they are not buried under target nodes.
 */
export declare function pathPointAt(points: number[], t: number): {
    x: number;
    y: number;
    tx: number;
    ty: number;
};
/**
 * Pick a label position along the path that stays outside node boxes when possible.
 * Tries several arc fractions + perpendicular offsets (keeps "no" visible past Process).
 */
export declare function placeEdgeLabelPoint(points: number[], obstacles: Obstacle[], preferredT?: number, preferredOffset?: number): {
    x: number;
    y: number;
};
/** Build a connector group: routed path + arrowheads + optional label */
export declare function createConnector(app: App, x1: number, y1: number, x2: number, y2: number, options?: ConnectorOptions): Group;
/** Curved mind-map branch (quadratic sampled as polyline), no arrowheads. */
export declare function createCurvedConnector(app: App, x1: number, y1: number, x2: number, y2: number, options?: ConnectorOptions): Group;
/** Connect two diagram nodes with orthogonal (or curved) routing */
export declare function connectNodes(app: App, from: Node, to: Node, obstacles: Obstacle[], options?: ConnectorOptions): Group;
export interface ConnectPairSpec {
    from: Node;
    to: Node;
    options?: ConnectorOptions;
}
/**
 * Connect many node pairs with shared fan-out planning so wires that leave
 * or enter the same card side do not stack on top of each other.
 * Mind-map / org bus wiring should not use this helper.
 */
export declare function connectNodePairs(app: App, pairs: ConnectPairSpec[], shared: ConnectorOptions & {
    parent: Group;
    obstacleNodes?: Node[];
}): Group[];
/** Wire org-chart with Mermaid flowchart-TB shared bus connectors */
export declare function wireOrgChartConnectors(app: App, root: Group): void;
/** Mermaid-style mind-map links (horizontal cubics on card edges — not subtree bounds). */
export declare function wireMindMapConnectors(app: App, group: Group): void;