import * as _foblex_2d from '@foblex/2d';
import { ITransformModel, IPoint, IRect, ISize, ILine, IRoundedRect, Point, IMinMaxPoint, RoundedRect } from '@foblex/2d';
import * as i0 from '@angular/core';
import { InjectionToken, OnInit, OnChanges, SimpleChanges, AfterContentInit, OnDestroy, InputSignalWithTransform, OutputEmitterRef, Signal, ElementRef, DestroyRef, Provider, ModelSignal, InputSignal, AfterViewInit, Renderer2, ProviderToken, Injector, TemplateRef, EventEmitter, Type } from '@angular/core';
import * as _foblex_flow from '@foblex/flow';
import { IExecution, IHandler, FMediator } from '@foblex/mediator';
import { BrowserService } from '@foblex/platform';
import * as i43 from '@angular/common';

declare const F_BACKGROUND_PATTERN: InjectionToken<IFBackgroundPattern>;
interface IFBackgroundPattern {
    hostElement: HTMLElement | SVGElement;
    setTransform(transform: ITransformModel): void;
}

declare class FRectPatternComponent implements OnInit, OnChanges, IFBackgroundPattern {
    private readonly _destroyRef;
    private readonly _elementReference;
    private readonly _fBrowser;
    private readonly _stateChanges;
    get hostElement(): HTMLElement;
    id: i0.InputSignal<string>;
    vColor: i0.InputSignal<string>;
    hColor: i0.InputSignal<string>;
    vSize: i0.InputSignalWithTransform<number, unknown>;
    hSize: i0.InputSignalWithTransform<number, unknown>;
    private _transform;
    private _position;
    private _size;
    private _pattern;
    private _vLine;
    private _hLine;
    constructor();
    private _createPattern;
    ngOnInit(): void;
    private _listenStateChanges;
    ngOnChanges(changes: SimpleChanges): void;
    private _redraw;
    private _calculatePattern;
    private _redrawPattern;
    private _redrawLine;
    setTransform(transform: ITransformModel): void;
    private _refresh;
    static ɵfac: i0.ɵɵFactoryDeclaration<FRectPatternComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FRectPatternComponent, "f-rect-pattern", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "vColor": { "alias": "vColor"; "required": false; "isSignal": true; }; "hColor": { "alias": "hColor"; "required": false; "isSignal": true; }; "vSize": { "alias": "vSize"; "required": false; "isSignal": true; }; "hSize": { "alias": "hSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FCirclePatternComponent implements OnInit, OnChanges, IFBackgroundPattern {
    private readonly _destroyRef;
    private readonly _elementReference;
    private readonly _fBrowser;
    private readonly _stateChanges;
    get hostElement(): HTMLElement;
    id: i0.InputSignal<string>;
    color: i0.InputSignal<string>;
    radius: i0.InputSignalWithTransform<number, unknown>;
    private _scaledRadius;
    private _transform;
    private _position;
    private _pattern;
    private _circle;
    constructor();
    private _createPattern;
    ngOnInit(): void;
    private _listenStateChanges;
    ngOnChanges(changes: SimpleChanges): void;
    private _redraw;
    private _calculatePattern;
    private _redrawPattern;
    private _redrawElement;
    setTransform(transform: ITransformModel): void;
    private _refresh;
    static ɵfac: i0.ɵɵFactoryDeclaration<FCirclePatternComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FCirclePatternComponent, "f-circle-pattern", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface IHasHostElement<T = HTMLElement | SVGElement> {
    hostElement: T;
}

declare const F_BACKGROUND: InjectionToken<FBackgroundBase>;
declare abstract class FBackgroundBase implements IHasHostElement {
    readonly hostElement: any;
    abstract setTransform(transform: ITransformModel): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FBackgroundBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FBackgroundBase, never, never, {}, {}, never, never, true, never>;
}

declare class FBackgroundComponent extends FBackgroundBase implements OnInit, AfterContentInit, OnDestroy {
    private readonly _mediator;
    protected readonly fBackgroundPattern: i0.Signal<_foblex_flow.IFBackgroundPattern | undefined>;
    ngOnInit(): void;
    ngAfterContentInit(): void;
    setTransform(transform: ITransformModel): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FBackgroundComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FBackgroundComponent, "f-background", never, {}, {}, ["fBackgroundPattern"], ["*"], true, never>;
}

declare const F_BACKGROUND_PROVIDERS: (typeof FRectPatternComponent | typeof FCirclePatternComponent | typeof FBackgroundComponent)[];

declare abstract class FAutoPanBase implements IHasHostElement {
    readonly hostElement: any;
    abstract fEdgeThreshold: InputSignalWithTransform<number, unknown>;
    abstract fSpeed: InputSignalWithTransform<number, unknown>;
    abstract fAcceleration: InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FAutoPanBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FAutoPanBase, never, never, {}, {}, never, never, true, never>;
}

declare class FAutoPan extends FAutoPanBase implements OnInit, OnDestroy {
    private readonly _mediator;
    fEdgeThreshold: i0.InputSignalWithTransform<number, unknown>;
    fSpeed: i0.InputSignalWithTransform<number, unknown>;
    fAcceleration: i0.InputSignalWithTransform<boolean, unknown>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FAutoPan, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FAutoPan, "f-auto-pan", never, { "fEdgeThreshold": { "alias": "fEdgeThreshold"; "required": false; "isSignal": true; }; "fSpeed": { "alias": "fSpeed"; "required": false; "isSignal": true; }; "fAcceleration": { "alias": "fAcceleration"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const F_AUTO_PAN_PROVIDERS: (typeof FAutoPan)[];

/**
 * Built-in layers rendered inside `<f-canvas>`. Each one corresponds to
 * a sibling container in the canvas template (groups, connections,
 * nodes) and gets its own z-index based on its position in the order
 * passed to `<f-canvas [fLayers]>` or `withFCanvas({ layers })`.
 *
 * The order of an array of `EFCanvasLayer` values is read **bottom to top**:
 * the first entry sits underneath, the last entry sits on top.
 */
declare enum EFCanvasLayer {
    GROUPS = "groups",
    CONNECTIONS = "connections",
    NODES = "nodes"
}

/**
 * Default rendering order, bottom to top:
 * groups → connections → nodes (matches every Foblex Flow release before v18.6).
 */
declare const F_DEFAULT_LAYER_ORDER: EFCanvasLayer[];

declare const F_CANVAS: InjectionToken<FCanvasBase>;
declare abstract class FCanvasBase implements IHasHostElement {
    abstract fCanvasChange: OutputEmitterRef<FCanvasChangeEvent>;
    readonly hostElement: any;
    abstract fGroupsContainer: Signal<ElementRef<HTMLElement>>;
    abstract fNodesContainer: Signal<ElementRef<HTMLElement>>;
    abstract fConnectionsContainer: Signal<ElementRef<HTMLElement>>;
    transform: _foblex_2d.ITransformModel;
    abstract debounce: Signal<number>;
    private readonly _fCanvasChange;
    protected readonly destroyRef: DestroyRef;
    abstract redraw(): void;
    abstract redrawWithAnimation(): void;
    getPosition(): IPoint;
    _setPosition(position: IPoint): void;
    abstract setScale(scale: number, toPosition: IPoint): void;
    abstract resetScale(): void;
    emitCanvasChangeEvent(): void;
    protected subscribeOnCanvasChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FCanvasBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FCanvasBase, never, never, {}, {}, never, never, true, never>;
}

declare class FCanvasChangeEvent {
    readonly position: IPoint;
    readonly scale: number;
    constructor(position: IPoint, scale: number);
}

/**
 * Normalises a user-supplied layer order into a complete, de-duplicated
 * `EFCanvasLayer[]`. Unknown entries are dropped, duplicates collapse to the
 * first occurrence, and any layer the caller forgot to mention is
 * appended in its default position so the canvas always has every layer
 * to render.
 */
declare function resolveLayerOrder(value: EFCanvasLayer[] | undefined | null): EFCanvasLayer[];

/**
 * Canvas-level configuration consumed by `withFCanvas(...)`.
 *
 * Currently a single field — `layers` — but the shape leaves room
 * for additional canvas-scoped knobs without spawning more `with*()`
 * helpers (e.g. canvas zoom defaults, padding, etc.).
 */
interface MergeFCanvasConfig {
    /**
     * Order in which built-in layers are stacked inside `<f-canvas>`,
     * read bottom to top. Defaults to
     * `[EFCanvasLayer.GROUPS, EFCanvasLayer.CONNECTIONS, EFCanvasLayer.NODES]`.
     *
     * Missing layers are appended in their default position; unknown
     * values and duplicates are silently dropped.
     */
    layers?: EFCanvasLayer[];
}
/**
 * Fully resolved canvas configuration. The injection token always
 * resolves to this shape — `withFCanvas` runs the partial config
 * through `mergeFCanvasConfig` before binding it to the token, so
 * downstream consumers never have to handle `undefined` fields.
 */
interface IFCanvasResolvedConfig {
    layers: EFCanvasLayer[];
}
declare const F_CANVAS_CONFIG: InjectionToken<IFCanvasResolvedConfig>;
declare function mergeFCanvasConfig(partial: MergeFCanvasConfig | undefined): IFCanvasResolvedConfig;

/**
 * Flow-level configuration passed as the first argument to `provideFFlow(...)`.
 *
 * Priority for `id`: `[fFlowId]` input on `<f-flow>` > this config > auto-generated.
 */
interface IFFlowConfig {
    id?: string;
}
declare const F_FLOW_CONFIG: InjectionToken<IFFlowConfig>;

/**
 * Discriminator for `with*()` features composed by `provideFFlow`.
 */
declare enum EFFlowFeatureKind {
    REFLOW_ON_RESIZE = "reflow-on-resize",
    CANVAS = "canvas"
}
/**
 * Feature envelope returned by `with*()` helpers.
 *
 * Each helper returns a kind tag and the provider list that activates the feature.
 * `provideFFlow` flattens these into a single `Provider[]` placed in the host's
 * `providers` array.
 */
interface IFFlowFeature<K extends EFFlowFeatureKind = EFFlowFeatureKind> {
    readonly kind: K;
    readonly providers: Provider[];
}

/**
 * Entry point for the provider-based Flow configuration surface.
 *
 * Usage:
 * ```typescript
 * providers: [
 *   provideFFlow(
 *     { id: 'main' },                // optional flow-level config
 *     withReflowOnResize({ ... }),    // feature plugins
 *   ),
 * ];
 * ```
 *
 * The first positional argument is an optional `IFFlowConfig`. Any argument that
 * carries a `kind` discriminator is treated as a feature.
 */
declare function provideFFlow(...features: IFFlowFeature[]): Provider[];
declare function provideFFlow(config: IFFlowConfig, ...features: IFFlowFeature[]): Provider[];

/**
 * Configures `<f-canvas>` inside `provideFFlow(...)`.
 *
 * ```typescript
 * @Component({
 *   providers: [
 *     provideFFlow(
 *       withFCanvas({ layers: [EFLayer.GROUPS, EFLayer.NODES, EFLayer.CONNECTIONS] }),
 *     ),
 *   ],
 * })
 * export class MyFlow {}
 * ```
 *
 * The order is read bottom to top — the first entry sits underneath,
 * the last entry sits on top. Missing layers are appended in their
 * default position.
 *
 * The same value can also be set per-instance via
 * `<f-canvas [fLayers]="...">`. The component input wins when both are
 * present, so `withFCanvas` acts as the app-wide default and individual
 * canvases can opt out without re-providing the feature.
 *
 * Registering the feature twice replaces the earlier config via
 * Angular's last-wins provider semantics.
 */
declare function withFCanvas(config?: MergeFCanvasConfig): IFFlowFeature<EFFlowFeatureKind.CANVAS>;

/**
 * Component representing a canvas in the F-Flow framework.
 * It handles the rendering of nodes, connections, and groups,
 * as well as user interactions such as zooming and panning.
 * It extends the FCanvasBase class and implements OnInit and OnDestroy lifecycle hooks.
 * It provides methods to manipulate the canvas, such as centering nodes or groups,
 * fitting the canvas to the screen, and resetting the scale.
 * It also emits events when the canvas changes, allowing other components to react to these changes.
 */
declare class FCanvasComponent extends FCanvasBase implements OnInit, OnDestroy {
    private readonly _mediator;
    private readonly _components;
    private readonly _injector;
    private readonly _config;
    private _flowId;
    fCanvasChange: i0.OutputEmitterRef<FCanvasChangeEvent>;
    readonly position: i0.InputSignalWithTransform<IPoint, IPoint | null | undefined>;
    readonly scale: i0.InputSignalWithTransform<number, unknown>;
    readonly debounceTime: i0.InputSignalWithTransform<number, unknown>;
    debounce: i0.Signal<number>;
    /**
     * Stacking order of the built-in layers (groups, connections, nodes),
     * read bottom to top. The first entry sits underneath, the last entry
     * sits on top. Defaults to the order shipped before v18.6:
     * `[GROUPS, CONNECTIONS, NODES]`.
     *
     * When `withFCanvas({ layers })` is provided in the component's
     * injector, this input falls back to that value; passing `fLayers`
     * directly always wins. Missing layers are appended in their default
     * position so every canvas renders all three regardless of input.
     */
    readonly fLayers: i0.InputSignal<EFCanvasLayer[] | undefined>;
    /**
     * Final layer order rendered in the template. The three sibling
     * containers are emitted in this order, which (combined with
     * `isolation: isolate` on each of them) is what visually stacks
     * groups, connections, and nodes — no per-container z-index involved.
     */
    protected readonly resolvedLayers: i0.Signal<EFCanvasLayer[]>;
    fGroupsContainer: i0.Signal<ElementRef<HTMLElement>>;
    fNodesContainer: i0.Signal<ElementRef<HTMLElement>>;
    fConnectionsContainer: i0.Signal<ElementRef<HTMLElement>>;
    get flowId(): string;
    ngOnInit(): void;
    private _positionChange;
    private _scaleChange;
    /**
     * Redraws the canvas by applying the current transformation.
     */
    redraw(): void;
    /**
     * Redraws the canvas with an animation effect.
     * This method applies a CSS transition to the canvas element,
     * allowing for a smooth visual update of the canvas's transformation.
     */
    redrawWithAnimation(): void;
    /**
     * Centers the specified group or node on the canvas.
     * @param groupOrNodeId - The ID of the group or node to center.
     * @param animated - If true, the centering will be animated; otherwise, it will be instantaneous.
     */
    centerGroupOrNode(groupOrNodeId: string, animated?: boolean): void;
    /**
     * Fits the canvas to the screen by adjusting the scale and position.
     * @param padding - paddings from the bounds of the canvas
     * @param animated - If true, the fit will be animated; otherwise, it will be instantaneous.
     */
    fitToScreen(padding?: IPoint, animated?: boolean): void;
    /**
     * Resets the scale and center all nodes and groups on the canvas.
     * This method is used to restore the canvas to its default scale and position,
     * allowing users to quickly return to a standard view of the canvas content.
     * @param animated - If true, the reset will be animated; otherwise, it will be instantaneous.
     * This is useful for providing a smooth user experience when resetting the view.
     */
    resetScaleAndCenter(animated?: boolean): void;
    /**
     *  Gets the current scale of the canvas.
     */
    getScale(): number;
    /**
     * Sets the scale of the canvas to a specified value.
     * This method is used to zoom in or out of the canvas,
     * allowing users to adjust the view of the canvas content.
     * @param scale - The scale factor to set for the canvas.
     * @param toPosition - The position to which the canvas should be centered after scaling.
     */
    setScale(scale: number, toPosition?: IPoint): void;
    /**
     * Resets the scale of the canvas to its default value.
     * This method is used to restore the canvas to its original scale.
     */
    resetScale(): void;
    ngOnDestroy(): void;
    private _afterRedraw;
    static ɵfac: i0.ɵɵFactoryDeclaration<FCanvasComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FCanvasComponent, "f-canvas", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "scale": { "alias": "scale"; "required": false; "isSignal": true; }; "debounceTime": { "alias": "debounceTime"; "required": false; "isSignal": true; }; "fLayers": { "alias": "fLayers"; "required": false; "isSignal": true; }; }, { "fCanvasChange": "fCanvasChange"; }, never, ["[fGroup], [fGroups]", "f-snap-connection", "f-connection, [fConnections]", "f-connection-for-create", "[fNode], [fNodes]"], true, never>;
}

declare const F_CANVAS_PROVIDERS: (typeof FCanvasComponent)[];

declare class AddPatternToBackgroundRequest {
    fPattern: IFBackgroundPattern | undefined;
    static readonly fToken: unique symbol;
    constructor(fPattern: IFBackgroundPattern | undefined);
}

/**
 * Execution that adds a pattern to the background in the FComponentsStore.
 */
declare class AddPatternToBackground implements IExecution<AddPatternToBackgroundRequest, void> {
    private readonly _store;
    private readonly _browser;
    private get _backgroundElement();
    handle(request: AddPatternToBackgroundRequest): void;
    private _getPatterns;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddPatternToBackground, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AddPatternToBackground>;
}

declare class SetBackgroundTransformRequest {
    fTransform: ITransformModel;
    static readonly fToken: unique symbol;
    constructor(fTransform: ITransformModel);
}

/**
 * Execution that sets the transform for the background when canvas is transformed.
 */
declare class SetBackgroundTransform implements IExecution<SetBackgroundTransformRequest, void> {
    private readonly _store;
    handle(request: SetBackgroundTransformRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SetBackgroundTransform, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SetBackgroundTransform>;
}

/**
 * This file exports all the background-related features for the F-Flow domain.
 * It includes executions for adding, removing, and setting the background in the FComponentsStore.
 */
declare const F_BACKGROUND_FEATURES: (typeof AddPatternToBackground | typeof SetBackgroundTransform)[];

declare class AddCanvasToStoreRequest {
    readonly instance: FCanvasBase;
    static readonly fToken: unique symbol;
    constructor(instance: FCanvasBase);
}

/**
 * Execution that adds a canvas to the FComponentsStore.
 */
declare class AddCanvasToStore implements IExecution<AddCanvasToStoreRequest, void> {
    private readonly _store;
    handle({ instance }: AddCanvasToStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddCanvasToStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AddCanvasToStore>;
}

declare class CenterGroupOrNodeRequest {
    id: string;
    animated: boolean;
    static readonly fToken: unique symbol;
    constructor(id: string, animated: boolean);
}

/**
 * Execution that centers a group or a node inside the flow.
 */
declare class CenterGroupOrNode implements IExecution<CenterGroupOrNodeRequest, void> {
    private readonly _store;
    private readonly _mediator;
    private get _transform();
    handle({ id, animated }: CenterGroupOrNodeRequest): void;
    private _toCenter;
    private _getNodeRect;
    private _getFlowRect;
    static ɵfac: i0.ɵɵFactoryDeclaration<CenterGroupOrNode, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CenterGroupOrNode>;
}

declare class FitToFlowRequest {
    readonly toCenter: IPoint;
    readonly animated: boolean;
    static readonly fToken: unique symbol;
    constructor(toCenter: IPoint, animated: boolean);
}

/**
 * Fits all nodes and groups to the flow by scaling and positioning them
 */
declare class FitToFlow implements IExecution<FitToFlowRequest, void> {
    private readonly _store;
    private get _transform();
    private readonly _mediator;
    handle({ toCenter, animated }: FitToFlowRequest): void;
    fitToParent(rect: IRect, parentRect: IRect, points: IPoint[], toCenter: IPoint): void;
    private _getZeroPositionWithoutScale;
    static ɵfac: i0.ɵɵFactoryDeclaration<FitToFlow, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FitToFlow>;
}

declare class InputCanvasPositionRequest {
    readonly transform: ITransformModel;
    readonly position: IPoint | undefined;
    static readonly fToken: unique symbol;
    constructor(transform: ITransformModel, position: IPoint | undefined);
}

/**
 * It updates the canvas position and redraws the canvas when the user set a new position using the input.
 */
declare class InputCanvasPosition implements IExecution<InputCanvasPositionRequest, void> {
    private readonly _store;
    handle({ transform, position }: InputCanvasPositionRequest): void;
    private _calculateTransformPosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputCanvasPosition, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InputCanvasPosition>;
}

declare class InputCanvasScaleRequest {
    transform: ITransformModel;
    scale: number | undefined;
    static readonly fToken: unique symbol;
    constructor(transform: ITransformModel, scale: number | undefined);
}

/**
 * Execution that handles the scaling of the input canvas.
 * It updates the scale of the canvas transform and redraws the canvas when the user sets a new scale using the input.
 */
declare class InputCanvasScale implements IExecution<InputCanvasScaleRequest, void> {
    private readonly _store;
    handle(request: InputCanvasScaleRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputCanvasScale, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InputCanvasScale>;
}

declare enum ECanvasRedrawContext {
    VIEWPORT_ONLY = "VIEWPORT_ONLY",
    WITH_CONNECTION_CHANGES = "WITH_CONNECTION_CHANGES"
}

declare class RedrawCanvasWithAnimationRequest {
    readonly animated: boolean;
    readonly context: ECanvasRedrawContext;
    static readonly fToken: unique symbol;
    constructor(animated: boolean, context?: ECanvasRedrawContext);
}

/**
 * Execution that redraws the canvas with or without animation based on the request.
 * If animated, it will redraw with animation and wait for the transition end to notify data change.
 * If not animated, it will redraw immediately and notify data change.
 */
declare class RedrawCanvasWithAnimation implements IExecution<RedrawCanvasWithAnimationRequest, void> {
    private readonly _store;
    private get _canvas();
    handle(request: RedrawCanvasWithAnimationRequest): void;
    private _redrawWithAnimation;
    private _redraw;
    static ɵfac: i0.ɵɵFactoryDeclaration<RedrawCanvasWithAnimation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RedrawCanvasWithAnimation>;
}

declare class RemoveCanvasFromStoreRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that removes the canvas from the FComponentsStore.
 */
declare class RemoveCanvasFromStore implements IExecution<RemoveCanvasFromStoreRequest, void> {
    private readonly _store;
    handle(_: RemoveCanvasFromStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveCanvasFromStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveCanvasFromStore>;
}

declare class ResetScaleRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that resets the scale of the canvas in the FComponentsStore.
 */
declare class ResetScale implements IExecution<ResetScaleRequest, void> {
    private readonly _store;
    private get _transform();
    handle(_: ResetScaleRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResetScale, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResetScale>;
}

declare class ResetScaleAndCenterRequest {
    readonly animated: boolean;
    static readonly fToken: unique symbol;
    constructor(animated: boolean);
}

/**
 * Execution that resets the scale of the canvas and centers the nodes and groups inside the flow.
 */
declare class ResetScaleAndCenter implements IExecution<ResetScaleAndCenterRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private get _transform();
    handle({ animated }: ResetScaleAndCenterRequest): void;
    _oneToOneCentering(rect: IRect, parentRect: IRect, points: IPoint[]): void;
    private _getZeroPositionWithoutScale;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResetScaleAndCenter, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResetScaleAndCenter>;
}

declare class UpdateScaleRequest {
    readonly scale: number;
    readonly toPosition: IPoint;
    static readonly fToken: unique symbol;
    constructor(scale: number, toPosition: IPoint);
}

/**
 * Execution that updates the scale of the canvas in the FComponentsStore.
 * Occurs when the fZoom directive or User call the setScale method.
 */
declare class UpdateScale implements IExecution<UpdateScaleRequest, void> {
    private readonly _store;
    private get _transform();
    handle({ scale, toPosition }: UpdateScaleRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateScale, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UpdateScale>;
}

/**
 * This file exports all the canvas-related executions that can be used in the FCanvas feature.
 */
declare const F_CANVAS_FEATURES: (typeof AddCanvasToStore | typeof CenterGroupOrNode | typeof FitToFlow | typeof InputCanvasPosition | typeof InputCanvasScale | typeof RedrawCanvasWithAnimation | typeof RemoveCanvasFromStore | typeof ResetScale | typeof ResetScaleAndCenter | typeof UpdateScale)[];

/** Unit tangent vector. */
interface ITangent extends IPoint {
}

/** Result of sampling the path. */
interface ISamplerResult {
    /** Interpolated point on the polyline. */
    point: IPoint;
    /** Unit tangent (segment direction) at that point. */
    tangent: ITangent;
    /** Whether the result was clamped to the path edge (start or end). */
    atEdge: boolean;
}

/**
 * Immutable polyline geometry with precomputed cumulative lengths and segment tangents.
 * Keep this class focused on geometry only; sampling/traversal lives in PolylineSampler.
 */
declare class Polyline {
    /** Cleaned points (with consecutive duplicates removed). */
    readonly points: IPoint[];
    /** Cumulative length from start to each vertex. Same length as `points`. */
    readonly cumulativeLengths: number[];
    /** Unit tangent per segment `i` for segment [i -> i+1]. Length = points.length - 1. */
    readonly segmentTangents: ITangent[];
    /** Total length of the polyline (>= 1 for the degenerate fallback). */
    readonly totalLength: number;
    /**
     * Construct a polyline from raw points.
     * Consecutive duplicate points are removed.
     * If less than 2 points remain, it falls back to a unit horizontal segment [0,0] → [1,0].
     */
    constructor(points: IPoint[]);
    /**
     * Create a polyline by cloning points (defensive copy).
     * @param points Raw input points; they will be copied and cleaned.
     */
    static from(points: IPoint[]): Polyline;
    /** Remove consecutive duplicate points. */
    private static _removeConsecutiveDuplicates;
}

/**
 * Provides sampling (interpolation) along a {@link Polyline}.
 * Separates traversal logic from pure geometry stored in {@link Polyline}.
 */
declare class PolylineSampler {
    private _polyline;
    /**
     * @param points Initial points to build the underlying polyline.
     *               You can later call {@link updatePoints} to rebuild.
     */
    constructor(points?: IPoint[]);
    /**
     * Rebuild the underlying polyline from new points.
     * @returns Total length of the rebuilt polyline.
     */
    updatePoints(points: IPoint[]): number;
    /**
     * Backward-compatible alias for older API naming.
     * @returns Total length of the rebuilt polyline.
     */
    calculateTotalLength(points: IPoint[]): number;
    /** Total length of the current polyline. */
    get totalLength(): number;
    /**
     * Sample a point by normalized progress along the whole length.
     *
     * - `progress = 0` → start vertex
     * - `progress = 1` → end vertex
     *
     * Uses a small edge threshold (0.5 units) to snap near-start/near-end queries to exact vertices,
     * mirroring the behavior in the original implementation.
     *
     * @param progress Normalized value in [0..1]. Values are clamped to this range.
     * @returns Interpolated point, segment tangent, and whether it was clamped to an edge.
     */
    getPointAtProgress(progress: number): ISamplerResult;
    /**
     * Backward-compatible alias.
     * Equivalent to {@link getPointAtProgress}.
     */
    getPointAtLength(progress: number): ISamplerResult;
    /**
     * Sample a point by absolute distance from the start (in the same units as your points).
     * This is a convenience wrapper over {@link getPointAtProgress}.
     *
     * @param distance Distance from 0 to {@link totalLength}. Values outside are clamped.
     * @returns Interpolated point, segment tangent, and whether it was clamped to an edge.
     */
    getPointAtDistance(distance: number): ISamplerResult;
    /** Binary-search the first index where cumulativeLengths[index] >= target. */
    private static _findRightIndex;
    /** Linear interpolation between `a` and `b`. */
    private static _lerp;
    /** Clamp `value` into [min, max]. */
    private static _clamp;
    /** Safe ratio `num / den` with tiny-denominator guard. */
    private static _safeRatio;
}

declare enum PolylineContentAlign {
    NONE = "none",
    ALONG = "along"
}

/** Domain contract for content item to be placed along the path. */
interface IPolylineContent {
    position: Signal<number>;
    offset: Signal<number>;
    align: Signal<PolylineContentAlign>;
    hostElement: HTMLElement;
    /**
     * Returns the latest measured size of the content's host element.
     *
     * Implementations cache the size and refresh it via a
     * `ResizeObserver` rather than reading the DOM on every call —
     * placement runs in a tight loop interleaved with style writes, so
     * a per-call `getBoundingClientRect()` forces a synchronous layout
     * flush per label and turns drag into a layout-thrashing storm at
     * a few hundred labels (see issue #304).
     */
    measureSize(): ISize;
}

/**
 * Encapsulates placement logic for a single content item along the path.
 */
declare class PolylineContentPlace {
    compute(sampler: PolylineSampler, content: IPolylineContent): {
        position: IPoint;
        rotationDeg: number;
    };
    private _clamp01;
    private _applyEdgeGuard;
    private _sizeAlongDirection;
    private _normalize180;
    private _keepUpright;
    private _calculateContentRotation;
}

/**
 * Engine that orchestrates positioning and orientation of all
 * connection contents along a computed path.
 */
declare class ConnectionContentLayoutEngine {
    private readonly _placement;
    constructor(_placement?: PolylineContentPlace);
    layout(points: IPoint[], contents: Iterable<IPolylineContent>): number;
    private _createTransformString;
}

declare const F_CONNECTION_CONTENT: InjectionToken<FConnectionContentBase>;
declare abstract class FConnectionContentBase implements IPolylineContent {
    /**
     * The host DOM element to which the directive is applied.
     * Used internally for positioning calculations.
     */
    readonly hostElement: any;
    private _cachedSize;
    private _observer;
    constructor();
    /**
     * Position along the connection.
     *
     * A normalized value in the range `0..1`:
     * - `0` — at the start of the connection,
     * - `1` — at the end of the connection,
     * - `0.5` — at the middle of the connection (default).
     */
    abstract position: Signal<number>;
    /**
     * Perpendicular offset from the connection line (in pixels).
     *
     * - Positive values shift the element to the right
     *   relative to the line direction.
     * - Negative values shift it to the left.
     * - Default: `0` (no shift).
     */
    abstract offset: Signal<number>;
    /**
     * Controls the orientation (rotation) of the content relative to the connection.
     *
     * Possible values:
     * - `'none'` — no rotation (default).
     * - `'along'` — aligned along the path (tangent).
     */
    abstract align: Signal<PolylineContentAlign>;
    measureSize(): ISize;
}

/**
 * Directive for placing custom user content (text, icons, buttons, etc.)
 * along a connection line.
 *
 * It allows you to specify the position along the connection,
 * shift the content sideways (perpendicular to the path),
 * apply a margin near the edges, and control orientation.
 *
 * ### Usage examples
 *
 * ```html
 * <!-- Text centered on the connection -->
 * <div fConnectionContent [position]="0.5">
 *   Hello
 * </div>
 *
 * <!-- Button near the start of the connection, shifted upward by 12px -->
 * <button fConnectionContent [position]="0.2" [offset]="-12">
 *   +
 * </button>
 *
 * <!-- Icon at the end of the connection, with 6px margin and rotated along the path -->
 * <span fConnectionContent [position]="1" [margin]="6" align="along">
 *   ⮕
 * </span>
 * ```
 */
declare class FConnectionContent extends FConnectionContentBase implements OnInit {
    private readonly _mediator;
    private readonly _injector;
    readonly position: i0.InputSignalWithTransform<number, unknown>;
    readonly offset: i0.InputSignalWithTransform<number, unknown>;
    readonly align: i0.InputSignalWithTransform<PolylineContentAlign, unknown>;
    ngOnInit(): void;
    private _listenChanges;
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionContent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionContent, "[fConnectionContent]", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const F_CONNECTION_WAYPOINTS: InjectionToken<FConnectionWaypointsBase>;
declare abstract class FConnectionWaypointsBase {
    readonly hostElement: any;
    readonly candidates: i0.WritableSignal<IPoint[]>;
    abstract waypoints: ModelSignal<IPoint[]>;
    abstract radius: Signal<number>;
    abstract visibility: Signal<boolean>;
    private _activeIndex;
    private _waypoints;
    insert(candidate: IPoint): void;
    select(waypoint: IPoint): void;
    move(point: IPoint): void;
    update(): void;
}

declare function findWaypointCandidate(connection: {
    fWaypoints: Signal<FConnectionWaypointsBase | undefined>;
}, position: IPoint): IPoint | undefined;

type WaypointPick<T> = {
    connection: T;
    waypoint: IPoint;
    candidate?: never;
} | {
    connection: T;
    candidate: IPoint;
    waypoint?: never;
};
type HasWaypoints = {
    fWaypoints: Signal<FConnectionWaypointsBase | undefined>;
};
declare function pickWaypoint<T extends HasWaypoints>(connections: readonly T[], position: IPoint): WaypointPick<T> | undefined;

declare function findExistingWaypoint(connection: {
    fWaypoints: Signal<FConnectionWaypointsBase | undefined>;
}, position: IPoint): IPoint | undefined;

declare function isPointerInsidePoint(point: IPoint, circleCenter: IPoint, radius: number): boolean;

declare class FConnectionWaypoints extends FConnectionWaypointsBase implements OnInit, OnDestroy {
    private readonly _mediator;
    private readonly _injector;
    private readonly _connection;
    readonly radius: i0.InputSignalWithTransform<number, unknown>;
    readonly waypoints: i0.ModelSignal<IPoint[]>;
    readonly visibility: i0.InputSignalWithTransform<boolean, unknown>;
    ngOnInit(): void;
    private _listenChanges;
    private _notifyDataChanged;
    protected remove(index: number, event: MouseEvent): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionWaypoints, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionWaypoints, "f-connection-waypoints", never, { "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "waypoints": { "alias": "waypoints"; "required": false; "isSignal": true; }; "visibility": { "alias": "visibility"; "required": false; "isSignal": true; }; }, { "waypoints": "waypointsChange"; }, never, never, true, never>;
}

declare enum EFMarkerType {
    START = "f-connection-marker-start",
    END = "f-connection-marker-end",
    SELECTED_START = "f-connection-selected-marker-start",
    SELECTED_END = "f-connection-selected-marker-end",
    START_ALL_STATES = "f-connection-marker-start-all-states",
    END_ALL_STATES = "f-connection-marker-end-all-states"
}

declare const F_CONNECTION_MARKER: InjectionToken<FConnectionMarkerBase>;
declare abstract class FConnectionMarkerBase {
    readonly fId: i0.WritableSignal<string>;
    readonly hostElement: any;
    abstract markerElement: SVGElement;
    abstract width: number;
    abstract height: number;
    abstract refX: number;
    abstract refY: number;
    abstract get type(): EFMarkerType;
    abstract orient: 'auto' | 'auto-start-reverse' | string;
    abstract markerUnits: 'strokeWidth' | 'userSpaceOnUse';
}

declare function coerceMarkerType(value: unknown, fallbackValue?: EFMarkerType): EFMarkerType;

declare class FConnectionMarkerArrow extends FConnectionMarkerBase {
    private readonly _markerElement;
    readonly _type: i0.InputSignalWithTransform<EFMarkerType, unknown>;
    get markerElement(): SVGSVGElement;
    width: number;
    height: number;
    refX: number;
    refY: number;
    get type(): EFMarkerType;
    orient: 'auto' | 'auto-start-reverse' | string;
    markerUnits: 'strokeWidth' | 'userSpaceOnUse';
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionMarkerArrow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionMarkerArrow, "f-connection-marker-arrow", never, { "_type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FConnectionMarkerCircle extends FConnectionMarkerBase {
    private readonly _markerElement;
    readonly _type: i0.InputSignalWithTransform<EFMarkerType, unknown>;
    get markerElement(): SVGSVGElement;
    width: number;
    height: number;
    refX: number;
    refY: number;
    get type(): EFMarkerType;
    orient: 'auto' | 'auto-start-reverse' | string;
    markerUnits: 'strokeWidth' | 'userSpaceOnUse';
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionMarkerCircle, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionMarkerCircle, "f-connection-marker-circle", never, { "_type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FConnectionMarker extends FConnectionMarkerBase implements OnInit, OnDestroy {
    private readonly _mediator;
    markerElement: SVGElement;
    width: number;
    height: number;
    refX: number;
    refY: number;
    type: EFMarkerType;
    orient: 'auto' | 'auto-start-reverse' | 'calculated' | string;
    markerUnits: 'strokeWidth' | 'userSpaceOnUse';
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionMarker, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionMarker, "svg[fMarker]", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "refX": { "alias": "refX"; "required": false; }; "refY": { "alias": "refY"; "required": false; }; "type": { "alias": "type"; "required": false; }; "orient": { "alias": "orient"; "required": false; }; "markerUnits": { "alias": "markerUnits"; "required": false; }; }, {}, never, never, false, never>;
    static ngAcceptInputType_type: unknown;
}

declare const F_CONNECTION_GRADIENT: InjectionToken<FConnectionGradientBase>;
declare abstract class FConnectionGradientBase {
    abstract fStartColor: Signal<string>;
    abstract fEndColor: Signal<string>;
}

declare abstract class FConnectionGradientRendererBase implements OnInit {
    private readonly _connection;
    private readonly _hostElement;
    private readonly _injector;
    private readonly _hostAttributes;
    private _startColor?;
    private _endColor?;
    abstract gradient: InputSignal<FConnectionGradientBase>;
    readonly gradientId: i0.Signal<string>;
    ngOnInit(): void;
    private _listenColorChanges;
    get stop1Element(): SVGStopElement;
    get stop2Element(): SVGStopElement;
    redraw(line: ILine): void;
    private _updateGradient;
    private _setFromColor;
    private _setToColor;
    private _setHostAttribute;
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionGradientRendererBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionGradientRendererBase, never, never, {}, {}, never, never, true, never>;
}

declare class FConnectionGradientRenderer extends FConnectionGradientRendererBase {
    readonly gradient: i0.InputSignal<FConnectionGradientBase>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionGradientRenderer, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionGradientRenderer, "linearGradient[fConnectionGradientRenderer]", never, { "gradient": { "alias": "fConnectionGradientRendererFor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FConnectionGradient extends FConnectionGradientBase {
    readonly fStartColor: i0.InputSignal<string>;
    readonly fEndColor: i0.InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionGradient, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionGradient, "f-connection-gradient", never, { "fStartColor": { "alias": "fStartColor"; "required": true; "isSignal": true; }; "fEndColor": { "alias": "fEndColor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const F_CONNECTION_PATH: InjectionToken<FConnectionPathBase>;
declare abstract class FConnectionPathBase {
    readonly hostElement: any;
    abstract initialize(): void;
    abstract setPath(path: string): void;
    abstract select(): void;
    abstract deselect(): void;
}

declare class FConnectionPath extends FConnectionPathBase {
    private readonly _connection;
    readonly useGradient: i0.InputSignal<boolean>;
    readonly linkToGradient: i0.Signal<string | null>;
    get fPathId(): string;
    get attrConnectionId(): string;
    initialize(): void;
    setPath(path: string): void;
    select(): void;
    deselect(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionPath, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionPath, "path[f-connection-path]", never, { "useGradient": { "alias": "useGradient"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare const F_CONNECTION_SELECTION: InjectionToken<FConnectionSelectionBase>;
declare abstract class FConnectionSelectionBase {
    readonly hostElement: any;
    abstract setPath(path: string): void;
}

declare class FConnectionSelection extends FConnectionSelectionBase {
    private readonly _connection;
    get connectionForSelectionId(): string;
    setPath(path: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionSelection, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionSelection, "path[fConnectionSelection]", never, {}, {}, never, never, false, never>;
}

declare const F_CONNECTION_DRAG_HANDLE_END: InjectionToken<FConnectionDragHandleBase>;
declare const F_CONNECTION_DRAG_HANDLE_START: InjectionToken<FConnectionDragHandleBase>;
declare abstract class FConnectionDragHandleBase {
    readonly hostElement: any;
    point: IPoint;
    protected readonly class = "f-connection-drag-handle";
    abstract redraw(penultimatePoint: IPoint, startPoint: IPoint): void;
    protected calculateCircleCenter(start: IPoint, end: IPoint, radius: number): IPoint;
}

declare class FConnectionDragHandleStart extends FConnectionDragHandleBase {
    redraw(penultimatePoint: IPoint, startPoint: IPoint): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionDragHandleStart, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionDragHandleStart, "circle[f-connection-drag-handle-start]", never, {}, {}, never, never, false, never>;
}

declare class FConnectionDragHandleEnd extends FConnectionDragHandleBase {
    redraw(penultimatePoint: IPoint, endPoint: IPoint): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionDragHandleEnd, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionDragHandleEnd, "circle[f-connection-drag-handle-end]", never, {}, {}, never, never, false, never>;
}

type Constructor<T> = new (...args: any[]) => T;
type AbstractConstructor<T = object> = abstract new (...args: any[]) => T;

interface ISelectable {
    fId: Signal<string>;
    fSelectionDisabled: Signal<boolean>;
    hostElement: HTMLElement | SVGElement;
    markAsSelected(): void;
    unmarkAsSelected(): void;
    isSelected(): boolean;
    markChildrenAsSelected?(): void;
    unmarkChildrenAsSelected?(): void;
}

declare const F_SELECTED_CLASS = "f-selected";
type CanChangeSelectionConstructor = Constructor<ISelectable> & AbstractConstructor<ISelectable>;
declare function mixinChangeSelection<T extends AbstractConstructor<IHasHostElement>>(base: T): CanChangeSelectionConstructor & T;

interface ICanChangeVisibility {
    hostElement: HTMLElement | SVGElement;
    show(): void;
    hide(): void;
}

type CanChangeVisibilityConstructor = Constructor<ICanChangeVisibility> & AbstractConstructor<ICanChangeVisibility>;
declare function mixinChangeVisibility<T extends AbstractConstructor<IHasHostElement>>(base: T): CanChangeVisibilityConstructor & T;

declare enum EFConnectionBehavior {
    FIXED = "fixed",
    FIXED_CENTER = "fixed_center",
    FLOATING = "floating"
}

declare enum EFConnectionConnectableSide {
    DEFAULT = "default",
    TOP = "top",
    BOTTOM = "bottom",
    LEFT = "left",
    RIGHT = "right",
    CALCULATE = "calculate",
    CALCULATE_HORIZONTAL = "calculate_horizontal",
    CALCULATE_VERTICAL = "calculate_vertical"
}

declare enum EFConnectableSide {
    LEFT = "left",
    TOP = "top",
    RIGHT = "right",
    BOTTOM = "bottom",
    CALCULATE = "calculate",
    CALCULATE_HORIZONTAL = "calculate_horizontal",
    CALCULATE_VERTICAL = "calculate_vertical",
    AUTO = "auto"
}

declare enum EFConnectionType {
    SEGMENT = "segment",
    STRAIGHT = "straight",
    BEZIER = "bezier",
    ADAPTIVE_CURVE = "adaptive-curve"
}

interface IConnectionEndpointRotationContext {
    rotationDeg: number;
    pivot: IPoint;
}
interface ICalculateBehaviorRequest {
    sourceRect: IRoundedRect;
    targetRect: IRoundedRect;
    sourceConnectableSide: EFConnectableSide;
    targetConnectableSide: EFConnectableSide;
    sourceRotationContext?: IConnectionEndpointRotationContext;
    targetRotationContext?: IConnectionEndpointRotationContext;
}

/**
 * Fixed center behavior calculates the connection line
 * It constructs a line between the gravity centers of the connector rectangles
 * @param payload
 */
declare function fixedCenterBehavior({ sourceRect, targetRect }: ICalculateBehaviorRequest): ILine;

/**
 * Fixed outbound behavior calculates the connection line
 * It constructs a line between the specified sides of the output and input rectangles
 * @param payload
 */
declare function fixedOutboundBehavior({ sourceRect, sourceConnectableSide, targetRect, targetConnectableSide, }: ICalculateBehaviorRequest): ILine;

/**
 * Floating behavior calculates the connection line
 * It constructs a line between the intersections of the connectors rectangles and line from the centers of the connector rectangles
 * @param payload
 */
declare function floatingBehavior({ sourceRect, targetRect, sourceRotationContext, targetRotationContext, }: ICalculateBehaviorRequest): ILine;

declare const F_CONNECTION_COMPONENTS_PARENT: InjectionToken<FConnectionComponentsParent>;
declare abstract class FConnectionComponentsParent {
    abstract fId: Signal<string>;
    abstract fOutputId: Signal<string>;
    abstract fInputId: Signal<string>;
    abstract fBehavior: EFConnectionBehavior;
    abstract _applyResolvedSidesToConnection(sourceSide: EFConnectableSide, targetSide: EFConnectableSide): void;
    abstract fInputSide: Signal<EFConnectionConnectableSide>;
    abstract fOutputSide: Signal<EFConnectionConnectableSide>;
}

declare class ConnectionBehaviourBuilderRequest {
    readonly sourceRect: IRoundedRect;
    readonly targetRect: IRoundedRect;
    readonly connection: FConnectionComponentsParent;
    readonly sourceConnectableSide: EFConnectableSide;
    readonly targetConnectableSide: EFConnectableSide;
    readonly sourceRotationContext?: IConnectionEndpointRotationContext | undefined;
    readonly targetRotationContext?: IConnectionEndpointRotationContext | undefined;
    constructor(sourceRect: IRoundedRect, targetRect: IRoundedRect, connection: FConnectionComponentsParent, sourceConnectableSide: EFConnectableSide, targetConnectableSide: EFConnectableSide, sourceRotationContext?: IConnectionEndpointRotationContext | undefined, targetRotationContext?: IConnectionEndpointRotationContext | undefined);
}

/**
 * Calculates connection lines based on behavior rules.
 * It determines which sides of the source and target should connect,
 * then delegates to a registered behavior handler.
 */
declare class ConnectionBehaviourBuilder {
    /**
     * Main execution entry point.
     *
     * @param request The request containing source, target, and connection details.
     * @returns A calculated connection line (ILine).
     */
    handle(request: ConnectionBehaviourBuilderRequest): ILine;
    /**
     * Computes the directional deltas between two rectangles.
     */
    private _calculateDirectionalVectors;
    /**
     * Determines the side for the source element.
     */
    private _determineSourceSide;
    /**
     * Determines the side for the target element.
     */
    private _determineTargetSide;
    /**
     * Resolves which side of a shape to connect to based on direction, fallback, and connection mode.
     *
     * @param requestedSide The side mode (e.g. CALCULATE, CALCULATE_HORIZONTAL, FIXED, etc.).
     * @param deltaX Difference in X between source and target.
     * @param deltaY Difference in Y between source and target.
     * @param fallbackSide The default fallback side if calculation is ambiguous.
     */
    private _resolveConnectableSide;
    /**
     * Returns the appropriate handler for the given connection behavior.
     *
     * @throws Error if no handler is registered for the behavior.
     */
    private _getBehaviorHandler;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionBehaviourBuilder, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectionBehaviourBuilder>;
}

interface IFConnectionBuilderRequest {
    source: IPoint;
    sourceSide: EFConnectableSide;
    target: IPoint;
    targetSide: EFConnectableSide;
    radius: number;
    offset: number;
    waypoints: IPoint[];
}

interface IFConnectionBuilderResponse {
    path: string;
    penultimatePoint: IPoint;
    secondPoint: IPoint;
    points: IPoint[];
    candidates: IPoint[];
}

interface IFConnectionBuilder {
    handle(request: IFConnectionBuilderRequest): IFConnectionBuilderResponse;
}

declare class CalculateAdaptiveCurveData implements IFConnectionBuilder {
    private static _dir;
    private static _isHorizontal;
    private static _handleLength;
    private static _softControl;
    handle({ source, sourceSide, target, targetSide, offset, waypoints, }: IFConnectionBuilderRequest): IFConnectionBuilderResponse;
}

declare class CalculateBezierCurveData implements IFConnectionBuilder {
    handle({ source, sourceSide, target, targetSide, offset, waypoints, }: IFConnectionBuilderRequest): IFConnectionBuilderResponse;
}

declare function buildCornerMidPointsAndApplyOffsets(params: {
    axis: 'x' | 'y';
    source: IPoint;
    target: IPoint;
    sourceSide: EFConnectableSide;
    targetSide: EFConnectableSide;
    sourceGap: IPoint;
    targetGap: IPoint;
    sourceDir: IPoint;
    targetDir: IPoint;
    currentDir: number;
    offset: number;
    sourceGapOffset: IPoint;
    targetGapOffset: IPoint;
}): IPoint[];

declare class CalculateSegmentLineData implements IFConnectionBuilder {
    handle({ source, sourceSide, target, targetSide, waypoints, offset, radius, }: IFConnectionBuilderRequest): IFConnectionBuilderResponse;
    private _getPathPoints;
    private _getDirection;
}

declare function createSegmentLinePath(points: IPoint[], borderRadius: number): string;

declare class CalculateStraightLineData implements IFConnectionBuilder {
    handle(request: IFConnectionBuilderRequest): IFConnectionBuilderResponse;
}

declare function buildConnectionAnchors(source: IPoint, target: IPoint, waypoints?: IPoint[]): IPoint[];

declare function calculateCenterBetweenPoints(source: IPoint, target: IPoint): IPoint;

interface ICubicSegment {
    p0: IPoint;
    c1: IPoint;
    c2: IPoint;
    p3: IPoint;
    chainIndex: number;
}
declare function createMultiCubicPath(segments: ICubicSegment[]): string;
declare function sampleMultiCubicUniform(segments: ICubicSegment[], samplesPerSegment?: number): IPoint[];

declare function calculateCurveCandidates(segments: ICubicSegment[]): IPoint[];

declare function calculatePolylineCandidates(polyline: IPoint[]): IPoint[];

declare function mergePointChains(chains: IPoint[][]): IPoint[];

declare function normalizePolyline(points: IPoint[], eps?: number): IPoint[];

/**
 * Uniformly samples a cubic Bézier segment.
 *
 * @param points - Start point, First control point, Second control point, End point.
 * @param samples - Number of sub-segments (default: 32). The function returns `samples + 1` points.
 * @returns Array of sampled points including both endpoints.
 * @remarks
 * Sampling is uniform in parameter `t`, not in arc length. This is typically
 * sufficient for hit-testing and bounding boxes; if you need error-bounded
 * flattening, consider an adaptive subdivision strategy instead.
 */
declare function sampleCubicBezierUniform(points: IPoint[], samples?: number): IPoint[];
/**
 * Evaluates a cubic Bézier at parameter `t` in [0, 1].
 *
 * @param p0 - Start point.
 * @param p1 - First control point.
 * @param p2 - Second control point.
 * @param p3 - End point.
 * @param t - Parameter in [0, 1].
 * @returns Point on the curve at `t`.
 */
declare function cubicBezierAtT(p0: IPoint, p1: IPoint, p2: IPoint, p3: IPoint, t: number): IPoint;

type IConnectionBuilders = Record<string, IFConnectionBuilder>;
declare const F_CONNECTION_BUILDERS: InjectionToken<IConnectionBuilders>;

declare class ConnectionLineBuilderRequest {
    readonly type: string | EFConnectionType;
    readonly payload: IFConnectionBuilderRequest;
    constructor(type: string | EFConnectionType, payload: IFConnectionBuilderRequest);
}

declare class ConnectionLineBuilder {
    private readonly _builtinBuilders;
    private readonly _providedBuilders;
    private readonly _builders;
    constructor();
    handle({ type, payload }: ConnectionLineBuilderRequest): IFConnectionBuilderResponse;
    private _createBuilderNotFoundError;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionLineBuilder, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectionLineBuilder>;
}

declare function createConnectionDomIdentifier(componentId: string, sourceId: string, targetId: string): string;

declare function createConnectionSelectionDomIdentifier(componentId: string, sourceId: string, targetId: string): string;

declare function createGradientDomIdentifier(componentId: string): string;

declare function createGradientDomUrl(componentId: string): string;

declare const MIXIN_BASE$1: _foblex_flow.Constructor<ISelectable> & _foblex_flow.AbstractConstructor<ISelectable> & _foblex_flow.Constructor<ICanChangeVisibility> & _foblex_flow.AbstractConstructor<ICanChangeVisibility> & {
    new (hostElement: HTMLElement): {
        hostElement: HTMLElement;
    };
};
declare abstract class FConnectionBase extends MIXIN_BASE$1 implements ISelectable, ICanChangeVisibility {
    private readonly _fConnectionBuilder;
    abstract fId: Signal<string>;
    abstract fOutputId: Signal<string>;
    abstract fInputId: Signal<string>;
    abstract fRadius: number;
    abstract fOffset: number;
    protected path: string;
    line: ILine;
    readonly fReassignableStart: Signal<boolean>;
    readonly fDraggingDisabled: Signal<boolean>;
    readonly fSelectionDisabled: Signal<boolean>;
    abstract boundingElement: HTMLElement | SVGElement;
    abstract fBehavior: EFConnectionBehavior;
    abstract fType: EFConnectionType | string;
    readonly fDefs: Signal<ElementRef<SVGDefsElement>>;
    readonly fPath: Signal<_foblex_flow.FConnectionPathBase>;
    readonly fDragHandleStart: Signal<_foblex_flow.FConnectionDragHandleBase | undefined>;
    readonly fDragHandleEnd: Signal<_foblex_flow.FConnectionDragHandleBase>;
    readonly fSelection: Signal<_foblex_flow.FConnectionSelectionBase>;
    readonly fContents: Signal<readonly FConnectionContentBase[]>;
    readonly fMarkers: Signal<readonly _foblex_flow.FConnectionMarkerBase[]>;
    readonly fGradient: Signal<_foblex_flow.FConnectionGradientBase | undefined>;
    private readonly _fGradientRenderer;
    readonly fWaypoints: Signal<_foblex_flow.FConnectionWaypointsBase | undefined>;
    readonly fInputSide: Signal<EFConnectionConnectableSide>;
    private readonly _contentLayoutEngine;
    private _sourceSide;
    readonly fOutputSide: Signal<EFConnectionConnectableSide>;
    private _targetSide;
    private _penultimatePoint;
    private _secondPoint;
    protected constructor();
    initialize(): void;
    isContains(element: HTMLElement | SVGElement): boolean;
    setLine({ point1, point2 }: ILine): void;
    private _contents;
    private _getPathResult;
    markChildrenAsSelected(): void;
    unmarkChildrenAsSelected(): void;
    redraw(): void;
    getResolvedSides(): {
        sourceSide: EFConnectableSide;
        targetSide: EFConnectableSide;
    };
    /**
     * Applies the resolved sides to the connection. Don't call this method directly; it's used internally.
     *
     * @param sourceSide The resolved side for the source element.
     * @param targetSide The resolved side for the target element.
     */
    _applyResolvedSidesToConnection(sourceSide: EFConnectableSide, targetSide: EFConnectableSide): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionBase, never, never, {}, {}, ["fContents", "fMarkers", "fGradient", "fWaypoints"], never, true, never>;
}

declare class FConnectionComponent extends FConnectionBase implements OnInit, OnChanges, OnDestroy {
    fId: i0.InputSignal<string>;
    fOutputId: i0.InputSignalWithTransform<string, unknown>;
    fInputId: i0.InputSignalWithTransform<string, unknown>;
    fRadius: number;
    fOffset: number;
    fBehavior: EFConnectionBehavior;
    fType: EFConnectionType | string;
    fSelectionDisabled: i0.InputSignalWithTransform<boolean, unknown>;
    fReassignableStart: i0.InputSignalWithTransform<boolean, unknown>;
    fDraggingDisabled: i0.InputSignalWithTransform<boolean, unknown>;
    fInputSide: i0.InputSignalWithTransform<EFConnectionConnectableSide, unknown>;
    fOutputSide: i0.InputSignalWithTransform<EFConnectionConnectableSide, unknown>;
    get boundingElement(): HTMLElement | SVGElement;
    private readonly _mediator;
    ngOnInit(): void;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionComponent, "f-connection", ["fComponent"], { "fId": { "alias": "fConnectionId"; "required": false; "isSignal": true; }; "fOutputId": { "alias": "fOutputId"; "required": false; "isSignal": true; }; "fInputId": { "alias": "fInputId"; "required": false; "isSignal": true; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "fSelectionDisabled": { "alias": "fSelectionDisabled"; "required": false; "isSignal": true; }; "fReassignableStart": { "alias": "fReassignableStart"; "required": false; "isSignal": true; }; "fDraggingDisabled": { "alias": "fReassignDisabled"; "required": false; "isSignal": true; }; "fInputSide": { "alias": "fInputSide"; "required": false; "isSignal": true; }; "fOutputSide": { "alias": "fOutputSide"; "required": false; "isSignal": true; }; }, {}, never, ["svg[fMarker]", "f-connection-marker-circle, f-connection-marker-arrow", "f-connection-gradient", "f-connection-waypoints", "[fConnectionContent]"], false, never>;
    static ngAcceptInputType_fRadius: unknown;
    static ngAcceptInputType_fOffset: unknown;
    static ngAcceptInputType_fBehavior: unknown;
}

declare class FConnectionForCreateComponent extends FConnectionBase implements AfterViewInit, OnInit, OnChanges, OnDestroy {
    fId: i0.WritableSignal<string>;
    fOutputId: i0.WritableSignal<string>;
    fInputId: i0.WritableSignal<string>;
    fRadius: number;
    fOffset: number;
    fBehavior: EFConnectionBehavior;
    fType: EFConnectionType | string;
    fInputSide: i0.InputSignalWithTransform<EFConnectionConnectableSide, unknown>;
    fOutputSide: i0.InputSignalWithTransform<EFConnectionConnectableSide, unknown>;
    get boundingElement(): HTMLElement | SVGElement;
    private readonly _mediator;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionForCreateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionForCreateComponent, "f-connection-for-create", never, { "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "fInputSide": { "alias": "fInputSide"; "required": false; "isSignal": true; }; "fOutputSide": { "alias": "fOutputSide"; "required": false; "isSignal": true; }; }, {}, never, ["svg[fMarker]", "f-connection-marker-circle, f-connection-marker-arrow", "f-connection-gradient", "[fConnectionContent]"], false, never>;
    static ngAcceptInputType_fRadius: unknown;
    static ngAcceptInputType_fOffset: unknown;
    static ngAcceptInputType_fBehavior: unknown;
}

declare class FSnapConnectionComponent extends FConnectionBase implements AfterViewInit, OnInit, OnChanges, OnDestroy {
    fId: i0.WritableSignal<string>;
    fSnapThreshold: number;
    fOutputId: i0.WritableSignal<string>;
    fInputId: i0.WritableSignal<string>;
    fRadius: number;
    fOffset: number;
    fBehavior: EFConnectionBehavior;
    fType: EFConnectionType | string;
    fInputSide: i0.InputSignalWithTransform<EFConnectionConnectableSide, unknown>;
    fOutputSide: i0.InputSignalWithTransform<EFConnectionConnectableSide, unknown>;
    get boundingElement(): HTMLElement | SVGElement;
    private readonly _mediator;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FSnapConnectionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FSnapConnectionComponent, "f-snap-connection", never, { "fSnapThreshold": { "alias": "fSnapThreshold"; "required": false; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "fInputSide": { "alias": "fInputSide"; "required": false; "isSignal": true; }; "fOutputSide": { "alias": "fOutputSide"; "required": false; "isSignal": true; }; }, {}, never, ["svg[fMarker]", "f-connection-marker-circle, f-connection-marker-arrow", "f-connection-gradient", "[fConnectionContent]"], false, never>;
    static ngAcceptInputType_fSnapThreshold: unknown;
    static ngAcceptInputType_fRadius: unknown;
    static ngAcceptInputType_fOffset: unknown;
    static ngAcceptInputType_fBehavior: unknown;
}

declare const F_CONNECTION_PROVIDERS: (typeof FConnectionMarker | typeof FConnectionPath | typeof FConnectionSelection | typeof FConnectionDragHandleStart | typeof FConnectionComponent | typeof FConnectionForCreateComponent | typeof FSnapConnectionComponent)[];
declare const F_CONNECTION_IMPORTS_EXPORTS: (typeof FConnectionContent | typeof FConnectionWaypoints | typeof FConnectionMarkerArrow | typeof FConnectionMarkerCircle | typeof FConnectionGradientRenderer | typeof FConnectionGradient)[];

declare class AddConnectionForCreateToStoreRequest {
    readonly connection: FConnectionForCreateComponent;
    static readonly fToken: unique symbol;
    constructor(connection: FConnectionForCreateComponent);
}

/**
 * Execution that adds a connection for creation to the FComponentsStore.
 */
declare class AddConnectionForCreateToStore implements IExecution<AddConnectionForCreateToStoreRequest, void> {
    private readonly _store;
    handle({ connection }: AddConnectionForCreateToStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddConnectionForCreateToStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AddConnectionForCreateToStore>;
}

declare class AddConnectionMarkerToStoreRequest {
    readonly instance: FConnectionMarkerBase;
    static readonly fToken: unique symbol;
    constructor(instance: FConnectionMarkerBase);
}

/**
 * Execution that adds a connection marker to the FComponentsStore.
 */
declare class AddConnectionMarkerToStore implements IExecution<AddConnectionMarkerToStoreRequest, void> {
    private readonly _store;
    handle({ instance }: AddConnectionMarkerToStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddConnectionMarkerToStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AddConnectionMarkerToStore>;
}

declare class AddConnectionToStoreRequest {
    readonly connection: FConnectionBase;
    static readonly fToken: unique symbol;
    constructor(connection: FConnectionBase);
}

/**
 * Execution that adds a connection to the FComponentsStore.
 */
declare class AddConnectionToStore implements IExecution<AddConnectionToStoreRequest, void> {
    private readonly _store;
    handle({ connection }: AddConnectionToStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddConnectionToStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AddConnectionToStore>;
}

declare class AddSnapConnectionToStoreRequest {
    readonly connection: FSnapConnectionComponent;
    static readonly fToken: unique symbol;
    constructor(connection: FSnapConnectionComponent);
}

/**
 * Execution that adds a snap connection to the FComponentsStore.
 */
declare class AddSnapConnectionToStore implements IExecution<AddSnapConnectionToStoreRequest, void> {
    private readonly _store;
    handle({ connection }: AddSnapConnectionToStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddSnapConnectionToStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AddSnapConnectionToStore>;
}

declare class CreateConnectionMarkersRequest {
    readonly connection: FConnectionBase;
    static readonly fToken: unique symbol;
    constructor(connection: FConnectionBase);
}

/**
 * Execution that creates connection markers for a given connection.
 */
declare class CreateConnectionMarkers implements IExecution<CreateConnectionMarkersRequest, boolean> {
    private readonly _browser;
    private readonly _markerCache;
    handle({ connection }: CreateConnectionMarkersRequest): boolean;
    _findConnectionMarkers(connection: FConnectionBase): FConnectionMarkerBase[];
    private _makeSafariCompatible;
    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionMarkers, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionMarkers>;
}

type FConnectorKind = 'input' | 'output' | 'outlet';
declare abstract class FConnectorBase implements IHasHostElement {
    abstract readonly kind: FConnectorKind;
    abstract fId: Signal<string>;
    abstract fNodeId: string;
    abstract fNodeHost: HTMLElement | SVGElement;
    abstract disabled: Signal<boolean>;
    abstract hostElement: HTMLElement | SVGElement;
    abstract canBeConnected: boolean;
    private _isConnected;
    get isConnected(): boolean;
    toConnector: FConnectorBase[];
    isSelfConnectable: boolean;
    fConnectableSide: EFConnectableSide;
    userFConnectableSide: EFConnectableSide;
    isContains(element: HTMLElement | SVGElement): boolean;
    setConnected(toConnector: FConnectorBase): void;
    resetConnected(): void;
}

declare const F_NODE_INPUT: InjectionToken<FNodeInputBase>;
declare abstract class FNodeInputBase extends FConnectorBase {
    kind: FConnectorKind;
    abstract category: Signal<string | undefined>;
    abstract multiple: Signal<boolean>;
    get canBeConnected(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<FNodeInputBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputBase, never, never, {}, {}, never, never, true, never>;
}

declare class FNodeInputDirective extends FNodeInputBase implements OnInit, OnChanges, OnDestroy {
    readonly hostElement: any;
    private readonly _mediator;
    private readonly _node;
    fId: i0.InputSignalWithTransform<string, unknown>;
    category: i0.InputSignalWithTransform<string | undefined, unknown>;
    multiple: i0.InputSignalWithTransform<boolean, unknown>;
    disabled: i0.InputSignalWithTransform<boolean, unknown>;
    userFConnectableSide: EFConnectableSide;
    get fNodeId(): string;
    get fNodeHost(): HTMLElement | SVGElement;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    setConnected(toConnector: FConnectorBase): void;
    resetConnected(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FNodeInputDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputDirective, "[fNodeInput]", ["fNodeInput"], { "fId": { "alias": "fInputId"; "required": false; "isSignal": true; }; "category": { "alias": "fInputCategory"; "required": false; "isSignal": true; }; "multiple": { "alias": "fInputMultiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "fInputDisabled"; "required": false; "isSignal": true; }; "userFConnectableSide": { "alias": "fInputConnectableSide"; "required": false; }; }, {}, never, never, false, never>;
    static ngAcceptInputType_userFConnectableSide: unknown;
}

declare abstract class FSourceConnectorBase extends FConnectorBase {
    abstract canBeConnectedInputs: string[];
    get hasConnectionLimits(): boolean;
    canConnectTo(targetConnector: FNodeInputBase): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<FSourceConnectorBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FSourceConnectorBase, never, never, {}, {}, never, never, true, never>;
}

declare const F_NODE_OUTLET: InjectionToken<FNodeOutletBase>;
declare abstract class FNodeOutletBase extends FSourceConnectorBase {
    kind: FConnectorKind;
    abstract isConnectionFromOutlet: boolean;
    private _outputs;
    get canBeConnected(): boolean;
    setOutputs(outputs: FConnectorBase[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutletBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletBase, never, never, {}, {}, never, never, true, never>;
}

declare function isNodeOutlet(element: HTMLElement | SVGElement): boolean;

declare class FNodeOutletDirective extends FNodeOutletBase implements OnInit, OnDestroy {
    readonly hostElement: any;
    private readonly _mediator;
    private readonly _node;
    fId: i0.InputSignalWithTransform<string, unknown>;
    disabled: i0.InputSignalWithTransform<boolean, unknown>;
    fConnectableSide: EFConnectableSide;
    userFConnectableSide: EFConnectableSide;
    isConnectionFromOutlet: boolean;
    canBeConnectedInputs: string[];
    get fNodeId(): string;
    get fNodeHost(): HTMLElement | SVGElement;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutletDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletDirective, "[fNodeOutlet]", ["fNodeOutlet"], { "fId": { "alias": "fOutletId"; "required": false; "isSignal": true; }; "disabled": { "alias": "fOutletDisabled"; "required": false; "isSignal": true; }; "isConnectionFromOutlet": { "alias": "isConnectionFromOutlet"; "required": false; }; "canBeConnectedInputs": { "alias": "fCanBeConnectedInputs"; "required": false; }; }, {}, never, never, false, never>;
}

declare const F_NODE_OUTPUT: InjectionToken<FNodeOutputBase>;
declare abstract class FNodeOutputBase extends FSourceConnectorBase {
    kind: FConnectorKind;
    abstract multiple: Signal<boolean>;
    get canBeConnected(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutputBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputBase, never, never, {}, {}, never, never, true, never>;
}

declare function isNodeOutput(element: HTMLElement | SVGElement): boolean;

declare class FNodeOutputDirective extends FNodeOutputBase implements OnInit, OnChanges, OnDestroy {
    readonly hostElement: any;
    private readonly _mediator;
    private readonly _node;
    fId: i0.InputSignalWithTransform<string, unknown>;
    multiple: i0.InputSignalWithTransform<boolean, unknown>;
    disabled: i0.InputSignalWithTransform<boolean, unknown>;
    userFConnectableSide: EFConnectableSide;
    isSelfConnectable: boolean;
    canBeConnectedInputs: string[];
    get fNodeId(): string;
    get fNodeHost(): HTMLElement | SVGElement;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    setConnected(toConnector: FConnectorBase): void;
    resetConnected(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutputDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputDirective, "[fNodeOutput]", ["fNodeOutput"], { "fId": { "alias": "fOutputId"; "required": false; "isSignal": true; }; "multiple": { "alias": "fOutputMultiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "fOutputDisabled"; "required": false; "isSignal": true; }; "userFConnectableSide": { "alias": "fOutputConnectableSide"; "required": false; }; "isSelfConnectable": { "alias": "isSelfConnectable"; "required": false; }; "canBeConnectedInputs": { "alias": "fCanBeConnectedInputs"; "required": false; }; }, {}, never, never, false, never>;
    static ngAcceptInputType_userFConnectableSide: unknown;
}

declare const F_CONNECTORS_PROVIDERS: (typeof FNodeInputDirective | typeof FNodeOutletDirective | typeof FNodeOutputDirective)[];

declare class ConnectionRedrawState {
    renderTicket: number;
    private readonly _connectedInPreviousRender;
    beginRender(): number;
    resetConnectedConnectors(): void;
    trackConnectedConnectors(source: FConnectorBase, target: FConnectorBase): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionRedrawState, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectionRedrawState>;
}

interface IConnectionWorkerResultItem {
    originalIndex: number;
    supported: boolean;
    sourceSide?: string;
    targetSide?: string;
    line?: ILine;
}

type TConnectionWorkerPendingRequest = {
    resolve: (value: IConnectionWorkerResultItem[]) => void;
    reject: (error: Error) => void;
};

declare class ConnectionWorkerState {
    worker: Worker | null;
    workerUrl: string | null;
    nextRequestId: number;
    isDisabled: boolean;
    pending: Map<number, TConnectionWorkerPendingRequest>;
    resetRuntime(error: Error): void;
    dispose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionWorkerState, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectionWorkerState>;
}

interface IConnectionEndpoints {
    source: FConnectorBase;
    target: FConnectorBase;
}

interface IConnectionGeometry extends IConnectionEndpoints {
    sourceRect: IRoundedRect;
    targetRect: IRoundedRect;
}

interface IConnectionRedrawSession {
    renderTicket: number;
    connectionsRevision: number;
    nodesRevision: number;
}

interface IConnectionWorkerRect {
    x: number;
    y: number;
    width: number;
    height: number;
    radius1: number;
    radius2: number;
    radius3: number;
    radius4: number;
}

interface IConnectionWorkerPayloadItem {
    originalIndex: number;
    behavior: string;
    outputSide: string;
    inputSide: string;
    sourceConnectableSide: string;
    targetConnectableSide: string;
    sourceRotation: number;
    targetRotation: number;
    sourceRect: IConnectionWorkerRect;
    targetRect: IConnectionWorkerRect;
}

interface IConnectionWorkerBatchItem {
    connection: FConnectionBase;
    geometry: IConnectionGeometry;
    payload: IConnectionWorkerPayloadItem;
}

interface IConnectionWorkerBatch {
    items: (IConnectionWorkerBatchItem | null)[];
    payload: IConnectionWorkerPayloadItem[];
}

interface IConnectionWorkerResponse {
    requestId: number;
    results?: IConnectionWorkerResultItem[];
    error?: string;
}

declare class ApplyConnectionRenderRequest {
    connection: FConnectionBase;
    line: ILine;
    static readonly fToken: unique symbol;
    constructor(connection: FConnectionBase, line: ILine);
}

declare class ApplyConnectionRender implements IExecution<ApplyConnectionRenderRequest, void> {
    private readonly _mediator;
    private readonly _renderCache;
    handle({ connection, line }: ApplyConnectionRenderRequest): void;
    private _shouldRender;
    private _createConnectionRenderSignature;
    private _serializePoint;
    private _serializeWaypoints;
    private _serializeContents;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplyConnectionRender, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApplyConnectionRender>;
}

declare class MarkConnectionConnectorsAsConnectedRequest {
    source: FConnectorBase;
    target: FConnectorBase;
    static readonly fToken: unique symbol;
    constructor(source: FConnectorBase, target: FConnectorBase);
}

declare class MarkConnectionConnectorsAsConnected implements IExecution<MarkConnectionConnectorsAsConnectedRequest, void> {
    private readonly _state;
    handle({ source, target }: MarkConnectionConnectorsAsConnectedRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MarkConnectionConnectorsAsConnected, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MarkConnectionConnectorsAsConnected>;
}

declare class RenderConnectionRequest {
    connection: FConnectionBase;
    cache: Map<string, IRoundedRect>;
    static readonly fToken: unique symbol;
    constructor(connection: FConnectionBase, cache: Map<string, IRoundedRect>);
}

declare class RenderConnection implements IExecution<RenderConnectionRequest, void> {
    private readonly _mediator;
    handle({ connection, cache }: RenderConnectionRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RenderConnection, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RenderConnection>;
}

declare class RenderConnectionFromGeometryRequest {
    connection: FConnectionBase;
    geometry: IConnectionGeometry;
    static readonly fToken: unique symbol;
    constructor(connection: FConnectionBase, geometry: IConnectionGeometry);
}

declare class RenderConnectionFromGeometry implements IExecution<RenderConnectionFromGeometryRequest, void> {
    private readonly _mediator;
    handle({ connection, geometry }: RenderConnectionFromGeometryRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RenderConnectionFromGeometry, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RenderConnectionFromGeometry>;
}

declare class RenderConnectionWithLineRequest {
    connection: FConnectionBase;
    source: FConnectorBase;
    target: FConnectorBase;
    line: ILine;
    static readonly fToken: unique symbol;
    constructor(connection: FConnectionBase, source: FConnectorBase, target: FConnectorBase, line: ILine);
}

declare class RenderConnectionWithLine implements IExecution<RenderConnectionWithLineRequest, void> {
    private readonly _mediator;
    handle({ connection, source, target, line }: RenderConnectionWithLineRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RenderConnectionWithLine, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RenderConnectionWithLine>;
}

declare class CompleteConnectionRedrawRequest {
    session: IConnectionRedrawSession;
    static readonly fToken: unique symbol;
    constructor(session: IConnectionRedrawSession);
}

declare class CompleteConnectionRedraw implements IExecution<CompleteConnectionRedrawRequest, void> {
    private readonly _mediator;
    private readonly _store;
    handle({ session }: CompleteConnectionRedrawRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CompleteConnectionRedraw, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CompleteConnectionRedraw>;
}

declare class IsConnectionRedrawCurrentRequest {
    session: IConnectionRedrawSession;
    static readonly fToken: unique symbol;
    constructor(session: IConnectionRedrawSession);
}

declare class IsConnectionRedrawCurrent implements IExecution<IsConnectionRedrawCurrentRequest, boolean> {
    private readonly _store;
    private readonly _state;
    handle({ session }: IsConnectionRedrawCurrentRequest): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsConnectionRedrawCurrent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IsConnectionRedrawCurrent>;
}

declare class RunConnectionRedrawSliceRequest {
    connections: FConnectionBase[];
    cache: Map<string, IRoundedRect>;
    startIndex: number;
    session: IConnectionRedrawSession;
    batchItems?: (IConnectionWorkerBatchItem | null)[] | undefined;
    workerResults?: (IConnectionWorkerResultItem | undefined)[] | undefined;
    static readonly fToken: unique symbol;
    constructor(connections: FConnectionBase[], cache: Map<string, IRoundedRect>, startIndex: number, session: IConnectionRedrawSession, batchItems?: (IConnectionWorkerBatchItem | null)[] | undefined, workerResults?: (IConnectionWorkerResultItem | undefined)[] | undefined);
}

declare class RunConnectionRedrawSlice implements IExecution<RunConnectionRedrawSliceRequest, void> {
    private readonly _mediator;
    private readonly _browser;
    handle({ connections, cache, startIndex, session, batchItems, workerResults, }: RunConnectionRedrawSliceRequest): void;
    private _isCurrent;
    private _requestAnimationFrame;
    private _now;
    private _isWithinSliceBudget;
    static ɵfac: i0.ɵɵFactoryDeclaration<RunConnectionRedrawSlice, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RunConnectionRedrawSlice>;
}

declare class StartConnectionRedrawRequest {
    static readonly fToken: unique symbol;
}

declare class StartConnectionRedraw implements IExecution<StartConnectionRedrawRequest, IConnectionRedrawSession> {
    private readonly _store;
    private readonly _state;
    handle(_: StartConnectionRedrawRequest): IConnectionRedrawSession;
    static ɵfac: i0.ɵɵFactoryDeclaration<StartConnectionRedraw, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StartConnectionRedraw>;
}

declare class RedrawConnectionsRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that redraws connections in the FComponentsStore.
 * It resets connectors, sets markers for temporary and snap connections,
 * and sets up connections based on the stored outputs and inputs.
 */
declare class RedrawConnections implements IExecution<RedrawConnectionsRequest, void> {
    private readonly _mediator;
    private readonly _store;
    handle(_: RedrawConnectionsRequest): void;
    private _createMarkersForCreate;
    private _createMarkersForSnap;
    private _shouldUseConnectionWorker;
    private _redrawUsingWorker;
    private _redrawWithoutWorker;
    static ɵfac: i0.ɵɵFactoryDeclaration<RedrawConnections, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RedrawConnections>;
}

declare class BuildConnectionLineRequest {
    connection: FConnectionBase;
    geometry: IConnectionGeometry;
    static readonly fToken: unique symbol;
    constructor(connection: FConnectionBase, geometry: IConnectionGeometry);
}

declare class BuildConnectionLine implements IExecution<BuildConnectionLineRequest, ILine> {
    private readonly _mediator;
    private readonly _connectionBehaviour;
    handle({ connection, geometry }: BuildConnectionLineRequest): ILine;
    private _resolveRotationContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<BuildConnectionLine, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BuildConnectionLine>;
}

declare class ResolveConnectionEndpointRectRequest {
    connector: FConnectorBase;
    cache: Map<string, IRoundedRect>;
    static readonly fToken: unique symbol;
    constructor(connector: FConnectorBase, cache: Map<string, IRoundedRect>);
}

declare class ResolveConnectionEndpointRect implements IExecution<ResolveConnectionEndpointRectRequest, IRoundedRect> {
    private readonly _mediator;
    handle({ connector, cache }: ResolveConnectionEndpointRectRequest): IRoundedRect;
    private _buildCacheKey;
    private _calculateRect;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResolveConnectionEndpointRect, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResolveConnectionEndpointRect>;
}

declare class ResolveConnectionEndpointsRequest {
    connection: FConnectionBase;
    static readonly fToken: unique symbol;
    constructor(connection: FConnectionBase);
}

declare class ResolveConnectionEndpoints implements IExecution<ResolveConnectionEndpointsRequest, IConnectionEndpoints | null> {
    private readonly _store;
    handle({ connection }: ResolveConnectionEndpointsRequest): IConnectionEndpoints | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResolveConnectionEndpoints, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResolveConnectionEndpoints>;
}

declare class ResolveConnectionGeometryRequest {
    connection: FConnectionBase;
    cache: Map<string, IRoundedRect>;
    static readonly fToken: unique symbol;
    constructor(connection: FConnectionBase, cache: Map<string, IRoundedRect>);
}

declare class ResolveConnectionGeometry implements IExecution<ResolveConnectionGeometryRequest, IConnectionGeometry | null> {
    private readonly _mediator;
    handle({ connection, cache, }: ResolveConnectionGeometryRequest): IConnectionGeometry | null;
    private _resolveConnectionEndpoints;
    private _resolveEndpointRect;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResolveConnectionGeometry, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResolveConnectionGeometry>;
}

declare class ApplyConnectionWorkerResultRequest {
    batchItem: IConnectionWorkerBatchItem | null;
    result?: IConnectionWorkerResultItem | undefined;
    static readonly fToken: unique symbol;
    constructor(batchItem: IConnectionWorkerBatchItem | null, result?: IConnectionWorkerResultItem | undefined);
}

declare class ApplyConnectionWorkerResult implements IExecution<ApplyConnectionWorkerResultRequest, void> {
    private readonly _mediator;
    handle({ batchItem, result }: ApplyConnectionWorkerResultRequest): void;
    private _fallbackToMainThread;
    private _isSupportedWorkerResult;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplyConnectionWorkerResult, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApplyConnectionWorkerResult>;
}

declare class BuildConnectionWorkerBatchRequest {
    connections: FConnectionBase[];
    cache: Map<string, IRoundedRect>;
    static readonly fToken: unique symbol;
    constructor(connections: FConnectionBase[], cache: Map<string, IRoundedRect>);
}

declare class BuildConnectionWorkerBatch implements IExecution<BuildConnectionWorkerBatchRequest, IConnectionWorkerBatch> {
    private readonly _mediator;
    handle({ connections, cache }: BuildConnectionWorkerBatchRequest): IConnectionWorkerBatch;
    private _buildBatchItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<BuildConnectionWorkerBatch, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BuildConnectionWorkerBatch>;
}

declare class BuildConnectionWorkerPayloadItemRequest {
    connection: FConnectionBase;
    geometry: IConnectionGeometry;
    originalIndex: number;
    static readonly fToken: unique symbol;
    constructor(connection: FConnectionBase, geometry: IConnectionGeometry, originalIndex: number);
}

declare class BuildConnectionWorkerPayloadItem implements IExecution<BuildConnectionWorkerPayloadItemRequest, IConnectionWorkerPayloadItem> {
    private readonly _store;
    handle({ connection, geometry, originalIndex, }: BuildConnectionWorkerPayloadItemRequest): IConnectionWorkerPayloadItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<BuildConnectionWorkerPayloadItem, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BuildConnectionWorkerPayloadItem>;
}

declare class DisableConnectionWorkerRequest {
    error: Error;
    static readonly fToken: unique symbol;
    constructor(error: Error);
}

declare class DisableConnectionWorker implements IExecution<DisableConnectionWorkerRequest, void> {
    private readonly _state;
    private readonly _mediator;
    handle({ error }: DisableConnectionWorkerRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DisableConnectionWorker, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DisableConnectionWorker>;
}

declare class EnsureConnectionWorkerRequest {
    static readonly fToken: unique symbol;
}

declare class EnsureConnectionWorker implements IExecution<EnsureConnectionWorkerRequest, Worker | null> {
    private readonly _browser;
    private readonly _state;
    private readonly _mediator;
    handle(_: EnsureConnectionWorkerRequest): Worker | null;
    private _disableWorker;
    private _resetWorkerAfterRuntimeError;
    static ɵfac: i0.ɵɵFactoryDeclaration<EnsureConnectionWorker, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EnsureConnectionWorker>;
}

declare class HandleConnectionWorkerMessageRequest {
    message?: IConnectionWorkerResponse | undefined;
    static readonly fToken: unique symbol;
    constructor(message?: IConnectionWorkerResponse | undefined);
}

declare class HandleConnectionWorkerMessage implements IExecution<HandleConnectionWorkerMessageRequest, void> {
    private readonly _state;
    handle({ message }: HandleConnectionWorkerMessageRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HandleConnectionWorkerMessage, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HandleConnectionWorkerMessage>;
}

declare class IsConnectionWorkerEnabledRequest {
    static readonly fToken: unique symbol;
}

declare class IsConnectionWorkerEnabled implements IExecution<IsConnectionWorkerEnabledRequest, boolean> {
    private readonly _browser;
    private readonly _state;
    handle(_: IsConnectionWorkerEnabledRequest): boolean;
    private _isWorkerAvailable;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsConnectionWorkerEnabled, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IsConnectionWorkerEnabled>;
}

declare class ResetConnectionWorkerRuntimeRequest {
    error: Error;
    static readonly fToken: unique symbol;
    constructor(error: Error);
}

declare class ResetConnectionWorkerRuntime implements IExecution<ResetConnectionWorkerRuntimeRequest, void> {
    private readonly _state;
    handle({ error }: ResetConnectionWorkerRuntimeRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResetConnectionWorkerRuntime, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResetConnectionWorkerRuntime>;
}

declare class RunConnectionWorkerRequest {
    payload: IConnectionWorkerPayloadItem[];
    static readonly fToken: unique symbol;
    constructor(payload: IConnectionWorkerPayloadItem[]);
}

declare class RunConnectionWorker implements IExecution<RunConnectionWorkerRequest, Promise<IConnectionWorkerResultItem[]>> {
    private readonly _state;
    private readonly _mediator;
    handle({ payload }: RunConnectionWorkerRequest): Promise<IConnectionWorkerResultItem[]>;
    private _interruptPendingRequests;
    static ɵfac: i0.ɵɵFactoryDeclaration<RunConnectionWorker, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RunConnectionWorker>;
}

declare class RunConnectionWorkerBatchRequest {
    batch: IConnectionWorkerBatch;
    static readonly fToken: unique symbol;
    constructor(batch: IConnectionWorkerBatch);
}

declare class RunConnectionWorkerBatch implements IExecution<RunConnectionWorkerBatchRequest, Promise<IConnectionWorkerResultItem[]>> {
    private readonly _mediator;
    handle({ batch, }: RunConnectionWorkerBatchRequest): Promise<IConnectionWorkerResultItem[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RunConnectionWorkerBatch, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RunConnectionWorkerBatch>;
}

type TConnectionWorkerUrlApi = Pick<typeof URL, 'createObjectURL' | 'revokeObjectURL'>;
type TConnectionWorkerRuntime = {
    blobCtor: typeof Blob;
    workerCtor: typeof Worker;
    urlApi: TConnectionWorkerUrlApi;
};
declare function isConnectionWorkerRuntimeSupported(windowRef: Window | null | undefined): boolean;
declare function resolveConnectionWorkerRuntime(windowRef: Window | null | undefined): TConnectionWorkerRuntime | null;
declare function createConnectionWorkerUrl(runtime: TConnectionWorkerRuntime): string;
declare function revokeConnectionWorkerUrl(workerUrl: string | null | undefined, urlApi?: Pick<typeof URL, 'revokeObjectURL'> | null): void;

declare class ShouldUseConnectionWorkerRequest {
    connectionCount: number;
    static readonly fToken: unique symbol;
    constructor(connectionCount: number);
}

declare class ShouldUseConnectionWorker implements IExecution<ShouldUseConnectionWorkerRequest, boolean> {
    private readonly _mediator;
    handle({ connectionCount }: ShouldUseConnectionWorkerRequest): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShouldUseConnectionWorker, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ShouldUseConnectionWorker>;
}

declare class StartConnectionWorkerRedrawRequest {
    connections: FConnectionBase[];
    cache: Map<string, IRoundedRect>;
    session: IConnectionRedrawSession;
    static readonly fToken: unique symbol;
    constructor(connections: FConnectionBase[], cache: Map<string, IRoundedRect>, session: IConnectionRedrawSession);
}

declare class StartConnectionWorkerRedraw implements IExecution<StartConnectionWorkerRedrawRequest, void> {
    private readonly _mediator;
    handle({ connections, cache, session }: StartConnectionWorkerRedrawRequest): void;
    private _alignWorkerResults;
    static ɵfac: i0.ɵɵFactoryDeclaration<StartConnectionWorkerRedraw, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StartConnectionWorkerRedraw>;
}

declare class ResolveConnectionEndpointRotationContextRequest {
    readonly connector?: FConnectorBase | undefined;
    static readonly fToken: unique symbol;
    constructor(connector?: FConnectorBase | undefined);
}
type TResolveConnectionEndpointRotationContextResponse = IConnectionEndpointRotationContext | undefined;

declare class ResolveConnectionEndpointRotationContext implements IExecution<ResolveConnectionEndpointRotationContextRequest, TResolveConnectionEndpointRotationContextResponse> {
    private readonly _store;
    private readonly _mediator;
    handle({ connector, }: ResolveConnectionEndpointRotationContextRequest): TResolveConnectionEndpointRotationContextResponse;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResolveConnectionEndpointRotationContext, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResolveConnectionEndpointRotationContext>;
}

declare class RemoveConnectionForCreateFromStoreRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that removes a connection for creation from the FComponentsStore.
 */
declare class RemoveConnectionForCreateFromStore implements IExecution<RemoveConnectionForCreateFromStoreRequest, void> {
    private readonly _store;
    handle(_request: RemoveConnectionForCreateFromStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveConnectionForCreateFromStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveConnectionForCreateFromStore>;
}

declare class RemoveConnectionFromStoreRequest {
    readonly connection: FConnectionBase;
    static readonly fToken: unique symbol;
    constructor(connection: FConnectionBase);
}

declare class RemoveConnectionFromStore implements IExecution<RemoveConnectionFromStoreRequest, void> {
    private readonly _store;
    handle({ connection }: RemoveConnectionFromStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveConnectionFromStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveConnectionFromStore>;
}

declare class RemoveConnectionMarkerFromStoreRequest {
    readonly instance: FConnectionMarkerBase;
    static readonly fToken: unique symbol;
    constructor(instance: FConnectionMarkerBase);
}

/**
 * Execution that removes a connection marker from the FComponentsStore.
 */
declare class RemoveConnectionMarkerFromStore implements IExecution<RemoveConnectionMarkerFromStoreRequest, void> {
    private readonly _store;
    handle({ instance }: RemoveConnectionMarkerFromStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveConnectionMarkerFromStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveConnectionMarkerFromStore>;
}

declare class RemoveConnectionWaypointRequest {
    readonly waypointIndex: number;
    readonly connectionId: string;
    static readonly fToken: unique symbol;
    constructor(waypointIndex: number, connectionId: string);
}

declare class RemoveConnectionWaypoint implements IExecution<RemoveConnectionWaypointRequest, void> {
    private readonly _store;
    handle({ waypointIndex, connectionId }: RemoveConnectionWaypointRequest): void;
    private _changeEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveConnectionWaypoint, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveConnectionWaypoint>;
}

declare class RemoveSnapConnectionFromStoreRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that removes the snap connection from the FComponentsStore.
 */
declare class RemoveSnapConnectionFromStore implements IExecution<RemoveSnapConnectionFromStoreRequest, void> {
    private readonly _store;
    handle(_request: RemoveSnapConnectionFromStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveSnapConnectionFromStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveSnapConnectionFromStore>;
}

/**
 * This file exports all the connection-related features for the F-Flow domain.
 */
declare const F_CONNECTION_FEATURES: (typeof ConnectionRedrawState | typeof ConnectionWorkerState | typeof AddConnectionForCreateToStore | typeof AddConnectionMarkerToStore | typeof AddConnectionToStore | typeof AddSnapConnectionToStore | typeof CreateConnectionMarkers | typeof ApplyConnectionWorkerResult | typeof ApplyConnectionRender | typeof BuildConnectionLine | typeof BuildConnectionWorkerBatch | typeof BuildConnectionWorkerPayloadItem | typeof CompleteConnectionRedraw | typeof DisableConnectionWorker | typeof EnsureConnectionWorker | typeof HandleConnectionWorkerMessage | typeof IsConnectionRedrawCurrent | typeof IsConnectionWorkerEnabled | typeof MarkConnectionConnectorsAsConnected | typeof RedrawConnections | typeof RenderConnection | typeof RenderConnectionFromGeometry | typeof RenderConnectionWithLine | typeof ResolveConnectionEndpointRect | typeof ResolveConnectionEndpointRotationContext | typeof ResolveConnectionEndpoints | typeof ResolveConnectionGeometry | typeof ResetConnectionWorkerRuntime | typeof RunConnectionRedrawSlice | typeof RunConnectionWorker | typeof RunConnectionWorkerBatch | typeof ShouldUseConnectionWorker | typeof StartConnectionRedraw | typeof StartConnectionWorkerRedraw | typeof RemoveConnectionForCreateFromStore | typeof RemoveConnectionFromStore | typeof RemoveConnectionMarkerFromStore | typeof RemoveSnapConnectionFromStore | typeof RemoveConnectionWaypoint)[];

declare class AddConnectorToStoreRequest {
    readonly instance: FConnectorBase;
    static readonly fToken: unique symbol;
    constructor(instance: FConnectorBase);
}

/**
 * Execution that adds an InputConnector to the FComponentsStore.
 */
declare class AddConnectorToStore implements IExecution<AddConnectorToStoreRequest, void> {
    private readonly _store;
    private readonly _mediator;
    handle({ instance }: AddConnectorToStoreRequest): void;
    private _addInput;
    private _addOutput;
    private _addOutlet;
    private _geometryRegister;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddConnectorToStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AddConnectorToStore>;
}

declare class CalculateClosestConnectorRequest {
    readonly position: IPoint;
    readonly connectorRefs: IConnectorRectRef[];
    static readonly fToken: unique symbol;
    constructor(position: IPoint, connectorRefs: IConnectorRectRef[]);
}

interface IConnectorRectRef<TConnector extends FConnectorBase = FConnectorBase> {
    connector: TConnector;
    rect: IRoundedRect;
}

/**
 * Interface that describes the closest connector to a point.
 */
interface IClosestConnectorRef<TConnector extends FConnectorBase = FConnectorBase> extends IConnectorRectRef<TConnector> {
    distance: number;
}

/**
 * Finds the closest connector rect to the given point.
 */
declare class CalculateClosestConnector implements IExecution<CalculateClosestConnectorRequest, IClosestConnectorRef | undefined> {
    handle({ position, connectorRefs, }: CalculateClosestConnectorRequest): IClosestConnectorRef | undefined;
    private _distanceToRect;
    private _clamp;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateClosestConnector, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateClosestConnector>;
}

declare class FindConnectableConnectorUsingPriorityAndPositionRequest {
    pointerPosition: IPoint;
    connectableConnectors: IConnectorRectRef[];
    static readonly fToken: unique symbol;
    constructor(pointerPosition: IPoint, connectableConnectors: IConnectorRectRef[]);
}

/**
 * Execution that finds a connectable connector at a given position with priority.
 * It checks for connectors at the position, the closest connector if snap connection is enabled,
 * and the first connectable connector of the node at that position.
 */
declare class FindConnectableConnectorUsingPriorityAndPosition implements IExecution<FindConnectableConnectorUsingPriorityAndPositionRequest, FConnectorBase | undefined> {
    private readonly _mediator;
    private readonly _store;
    private readonly _browser;
    private get _transform();
    private get _flowHost();
    private get _fNodes();
    private get _snapConnection();
    handle(payload: FindConnectableConnectorUsingPriorityAndPositionRequest): FConnectorBase | undefined;
    private _findConnectorAtPosition;
    private _filterConnectorsThatLocatedAtPosition;
    private _calculatePointerInFlow;
    private _isSnapConnectionEnabledAndHasClosestConnector;
    private _isValidClosestInput;
    private _getFirstConnectableConnectorOfNodeAtPosition;
    private _getElementsFromPoint;
    private _findConnectableNode;
    private _findFirstConnectableConnectorOfNode;
    static ɵfac: i0.ɵɵFactoryDeclaration<FindConnectableConnectorUsingPriorityAndPosition, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FindConnectableConnectorUsingPriorityAndPosition>;
}

declare class CalculateTargetConnectorsToConnectRequest {
    readonly source: FNodeOutputBase | FNodeOutletBase;
    readonly pointer: IPoint;
    static readonly fToken: unique symbol;
    constructor(source: FNodeOutputBase | FNodeOutletBase, pointer: IPoint);
}

/**
 * Returns all input connectors that can be connected to the given source (output or outlet),
 * along with their rect references.
 */
declare class CalculateTargetConnectorsToConnect implements IExecution<CalculateTargetConnectorsToConnectRequest, IConnectorRectRef[]> {
    private readonly _mediator;
    private readonly _store;
    private get _targets();
    handle({ source, pointer, }: CalculateTargetConnectorsToConnectRequest): IConnectorRectRef[];
    private _getConnectableTargets;
    private _scheduleApplyCalculatedSides;
    private _applyCalculatedConnectableSides;
    /** Delegates to the connected-positions calculation execution. */
    private _calculateByConnectedPositions;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateTargetConnectorsToConnect, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateTargetConnectorsToConnect>;
}

declare class CalculateSourceConnectorsToConnectRequest {
    readonly target: FNodeInputBase;
    readonly pointer: IPoint;
    static readonly fToken: unique symbol;
    constructor(target: FNodeInputBase, pointer: IPoint);
}

/**
 * Returns all source connectors (outputs/outlets) that can connect to the given target input,
 * along with their rect references.
 */
declare class CalculateSourceConnectorsToConnect implements IExecution<CalculateSourceConnectorsToConnectRequest, IConnectorRectRef[]> {
    private readonly _mediator;
    private readonly _store;
    private get _sources();
    handle({ target, pointer, }: CalculateSourceConnectorsToConnectRequest): IConnectorRectRef[];
    private _getConnectableSources;
    private _scheduleApplyCalculatedSides;
    private _applyCalculatedConnectableSides;
    /** Delegates to the connected-positions calculation execution. */
    private _calculateByConnectedPositions;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateSourceConnectorsToConnect, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateSourceConnectorsToConnect>;
}

declare class GetConnectorRectReferenceRequest {
    readonly connector: FConnectorBase;
    static readonly fToken: unique symbol;
    constructor(connector: FConnectorBase);
}

/**
 * Returns a connector + its normalized rounded rect.
 */
declare class GetConnectorRectReference implements IExecution<GetConnectorRectReferenceRequest, IConnectorRectRef> {
    private readonly _mediator;
    handle({ connector }: GetConnectorRectReferenceRequest): IConnectorRectRef;
    private _getRect;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetConnectorRectReference, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GetConnectorRectReference>;
}

declare class MarkConnectableConnectorsRequest {
    readonly connectors: FConnectorBase[];
    static readonly fToken: unique symbol;
    constructor(connectors: FConnectorBase[]);
}

/**
 * Execution that marks connectors as connectable.
 */
declare class MarkConnectableConnectors implements IExecution<MarkConnectableConnectorsRequest, void> {
    private readonly _store;
    handle({ connectors }: MarkConnectableConnectorsRequest): void;
    private _markConnector;
    static ɵfac: i0.ɵɵFactoryDeclaration<MarkConnectableConnectors, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MarkConnectableConnectors>;
}

declare class RemoveConnectorFromStoreRequest {
    readonly instance: FConnectorBase;
    static readonly fToken: unique symbol;
    constructor(instance: FConnectorBase);
}

/**
 * Execution that removes an inputConnector from the FComponentsStore.
 */
declare class RemoveConnectorFromStore implements IExecution<RemoveConnectorFromStoreRequest, void> {
    private readonly _store;
    private readonly _mediator;
    handle({ instance }: RemoveConnectorFromStoreRequest): void;
    private _removeInput;
    private _removeOutput;
    private _removeOutlet;
    private _geometryUnregister;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveConnectorFromStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveConnectorFromStore>;
}

declare class UnmarkConnectableConnectorsRequest {
    readonly connectors: FConnectorBase[];
    static readonly fToken: unique symbol;
    constructor(connectors: FConnectorBase[]);
}

/**
 * Execution that unmarks connectors as connectable.
 */
declare class UnmarkConnectableConnectors implements IExecution<UnmarkConnectableConnectorsRequest, void> {
    private readonly _store;
    handle({ connectors }: UnmarkConnectableConnectorsRequest): void;
    private _unmarkConnector;
    static ɵfac: i0.ɵɵFactoryDeclaration<UnmarkConnectableConnectors, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UnmarkConnectableConnectors>;
}

declare const F_CONNECTORS_FEATURES: (typeof AddConnectorToStore | typeof RemoveConnectorFromStore | typeof CalculateClosestConnector | typeof FindConnectableConnectorUsingPriorityAndPosition | typeof CalculateSourceConnectorsToConnect | typeof CalculateTargetConnectorsToConnect | typeof GetConnectorRectReference | typeof MarkConnectableConnectors | typeof UnmarkConnectableConnectors)[];

declare class EmitEndDragSequenceEventRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that handles the end of a drag sequence.
 */
declare class EmitEndDragSequenceEvent implements IExecution<EmitEndDragSequenceEventRequest, void> {
    private readonly _store;
    private readonly _dragSession;
    handle(_request: EmitEndDragSequenceEventRequest): void;
    private _emitEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmitEndDragSequenceEvent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EmitEndDragSequenceEvent>;
}

declare class EmitStartDragSequenceEventRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that starts the drag sequence by adding a dragging class to the host element
 */
declare class EmitStartDragSequenceEvent implements IExecution<EmitStartDragSequenceEventRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragContext;
    handle(_request: EmitStartDragSequenceEventRequest): void;
    private _emitDragStarted;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmitStartDragSequenceEvent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EmitStartDragSequenceEvent>;
}

declare class EmitSelectionChangeEventRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that emits a selection change event when the selection changes.
 * It retrieves the current selection and emits it through the FSelectionChangeEvent.
 */
declare class EmitSelectionChangeEvent implements IExecution<EmitSelectionChangeEventRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragSession;
    handle(_request: EmitSelectionChangeEventRequest): void;
    private _getSelection;
    private _emitSelectionChange;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmitSelectionChangeEvent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EmitSelectionChangeEvent>;
}

declare enum EFResizeHandleType {
    LEFT = "left",
    LEFT_TOP = "left-top",
    TOP = "top",
    RIGHT_TOP = "right-top",
    RIGHT = "right",
    RIGHT_BOTTOM = "right-bottom",
    BOTTOM = "bottom",
    LEFT_BOTTOM = "left-bottom"
}

declare class FResizeHandleDirective {
    type: i0.InputSignalWithTransform<EFResizeHandleType, unknown>;
    protected class: i0.Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FResizeHandleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FResizeHandleDirective, "[fResizeHandle]", never, { "type": { "alias": "fResizeHandleType"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare class FRotateHandleDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<FRotateHandleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FRotateHandleDirective, "[fRotateHandle]", never, {}, {}, never, never, false, never>;
}

declare function isRotateHandle(element: HTMLElement): boolean;

declare class FDragHandleDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<FDragHandleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FDragHandleDirective, "[fDragHandle]", never, {}, {}, never, never, false, never>;
}

type FChannelListener = () => void;
type FChannelOperator = (callback: FChannelListener) => {
    callback: FChannelListener;
    cleanup?: () => void;
    onSubscribe?: (finalCallback: FChannelListener) => void;
    setTeardown?: (teardown: () => void) => void;
};

declare function afterNextPaint(): FChannelOperator;

declare function debounceAnimationFrame(): FChannelOperator;

declare function debounceMicrotask(): FChannelOperator;

declare function debounceTime(delay: number): FChannelOperator;

declare class FChannel {
    protected _listeners: Set<FChannelListener>;
    notify(): void;
    listen(callback: FChannelListener): () => void;
    stop(callback: FChannelListener): void;
}

declare class FResizeChannel extends FChannel {
    private readonly _htmlElement;
    private readonly _observer;
    private _isObserving;
    constructor(_htmlElement: HTMLElement | SVGElement);
    listen(callback: FChannelListener): () => void;
    stop(callback: FChannelListener): void;
    private _disconnect;
}

declare class FChannelHub {
    private readonly _channels;
    private _operators;
    constructor(...channels: FChannel[]);
    pipe(...operators: FChannelOperator[]): FChannelHub;
    listen(destroyRef: DestroyRef, callback: FChannelListener): void;
}

declare function notifyOnStart(): FChannelOperator;

declare function takeOne(): FChannelOperator;

declare const F_NODE: InjectionToken<FNodeBase>;
declare const MIXIN_BASE: _foblex_flow.Constructor<ISelectable> & _foblex_flow.AbstractConstructor<ISelectable> & {
    new (hostElement: HTMLElement): {
        hostElement: HTMLElement;
    };
};
declare abstract class FNodeBase extends MIXIN_BASE implements ISelectable, IHasHostElement {
    private readonly _injector;
    protected readonly renderer: Renderer2;
    protected readonly browser: BrowserService;
    abstract fId: Signal<string>;
    abstract fParentId: Signal<string | null | undefined>;
    readonly stateChanges: FChannel;
    abstract position: ModelSignal<IPoint>;
    _position: IPoint;
    abstract rotate: ModelSignal<number>;
    _rotate: number;
    abstract sizeChange: OutputEmitterRef<IRect>;
    abstract size: InputSignal<ISize | undefined>;
    _size: ISize | undefined;
    abstract fConnectOnNode: Signal<boolean>;
    abstract fMinimapClass: Signal<string[] | string>;
    abstract fDraggingDisabled: Signal<boolean>;
    abstract fAutoExpandOnChildHit: Signal<boolean>;
    abstract fAutoSizeToFitChildren: Signal<boolean>;
    abstract fIncludePadding: Signal<boolean>;
    abstract refresh(): void;
    connectors: FConnectorBase[];
    protected positionChanges(): void;
    protected sizeChanges(): void;
    protected rotateChanges(): void;
    protected parentChanges(): void;
    private _isSizeEqual;
    protected abstract setStyle(name: string, value: string): void;
    protected abstract removeStyle(name: string): void;
    isContains(element: HTMLElement | SVGElement): boolean;
    redraw(): void;
    resetSize(): void;
    updatePosition(position: IPoint): void;
    updateRotate(rotate: number): void;
    updateSize(value: ISize): void;
    setClass(className: string): void;
    removeClass(className: string): void;
    addConnector(connector: FConnectorBase): void;
    removeConnector(connector: FConnectorBase): void;
}

declare class FGroupDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {
    private _debounceTimer;
    private readonly _destroyRef;
    private readonly _mediator;
    readonly fId: i0.InputSignal<string>;
    readonly fParentId: i0.InputSignal<string | null | undefined>;
    readonly position: i0.ModelSignal<_foblex_2d.IPoint>;
    readonly size: i0.InputSignal<ISize | undefined>;
    sizeChange: i0.OutputEmitterRef<IRect>;
    readonly rotate: i0.ModelSignal<number>;
    readonly fConnectOnNode: i0.InputSignalWithTransform<boolean, unknown>;
    readonly fMinimapClass: i0.InputSignal<string | string[]>;
    readonly fDraggingDisabled: i0.InputSignalWithTransform<boolean, unknown>;
    readonly fSelectionDisabled: i0.InputSignalWithTransform<boolean, unknown>;
    readonly fIncludePadding: i0.InputSignalWithTransform<boolean, unknown>;
    readonly fAutoExpandOnChildHit: i0.InputSignalWithTransform<boolean, unknown>;
    readonly fAutoSizeToFitChildren: i0.InputSignalWithTransform<boolean, unknown>;
    constructor(elementReference: ElementRef<HTMLElement>);
    ngOnInit(): void;
    protected setStyle(styleName: string, value: string): void;
    protected removeStyle(styleName: string): void;
    redraw(): void;
    protected _updateConnectorsSides(): void;
    private _calculateNodeConnectorsConnectableSides;
    ngAfterViewInit(): void;
    private _listenStateSizeChanges;
    refresh(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FGroupDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FGroupDirective, "[fGroup]", ["fComponent"], { "fId": { "alias": "fGroupId"; "required": false; "isSignal": true; }; "fParentId": { "alias": "fGroupParentId"; "required": false; "isSignal": true; }; "position": { "alias": "fGroupPosition"; "required": false; "isSignal": true; }; "size": { "alias": "fGroupSize"; "required": false; "isSignal": true; }; "rotate": { "alias": "fGroupRotate"; "required": false; "isSignal": true; }; "fConnectOnNode": { "alias": "fConnectOnNode"; "required": false; "isSignal": true; }; "fMinimapClass": { "alias": "fMinimapClass"; "required": false; "isSignal": true; }; "fDraggingDisabled": { "alias": "fGroupDraggingDisabled"; "required": false; "isSignal": true; }; "fSelectionDisabled": { "alias": "fGroupSelectionDisabled"; "required": false; "isSignal": true; }; "fIncludePadding": { "alias": "fIncludePadding"; "required": false; "isSignal": true; }; "fAutoExpandOnChildHit": { "alias": "fAutoExpandOnChildHit"; "required": false; "isSignal": true; }; "fAutoSizeToFitChildren": { "alias": "fAutoSizeToFitChildren"; "required": false; "isSignal": true; }; }, { "position": "fGroupPositionChange"; "sizeChange": "fGroupSizeChange"; "rotate": "fGroupRotateChange"; }, never, never, false, never>;
}

declare class FNodeDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {
    private _debounceTimer;
    private readonly _destroyRef;
    private readonly _mediator;
    readonly fId: i0.InputSignalWithTransform<string, unknown>;
    readonly fParentId: i0.InputSignal<string | null | undefined>;
    readonly position: i0.ModelSignal<_foblex_2d.IPoint>;
    readonly size: i0.InputSignal<ISize | undefined>;
    sizeChange: i0.OutputEmitterRef<IRect>;
    readonly rotate: i0.ModelSignal<number>;
    readonly fConnectOnNode: i0.InputSignalWithTransform<boolean, unknown>;
    readonly fMinimapClass: i0.InputSignal<string | string[]>;
    readonly fDraggingDisabled: i0.InputSignalWithTransform<boolean, unknown>;
    readonly fSelectionDisabled: i0.InputSignalWithTransform<boolean, unknown>;
    readonly fIncludePadding: i0.InputSignalWithTransform<boolean, unknown>;
    readonly fAutoExpandOnChildHit: i0.InputSignalWithTransform<boolean, unknown>;
    readonly fAutoSizeToFitChildren: i0.InputSignalWithTransform<boolean, unknown>;
    constructor(elementReference: ElementRef<HTMLElement>);
    ngOnInit(): void;
    protected setStyle(styleName: string, value: string): void;
    protected removeStyle(styleName: string): void;
    redraw(): void;
    protected _updateConnectorsSides(): void;
    private _calculateNodeConnectorsConnectableSides;
    ngAfterViewInit(): void;
    private _listenStateSizeChanges;
    refresh(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FNodeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeDirective, "[fNode]", ["fComponent"], { "fId": { "alias": "fNodeId"; "required": false; "isSignal": true; }; "fParentId": { "alias": "fNodeParentId"; "required": false; "isSignal": true; }; "position": { "alias": "fNodePosition"; "required": false; "isSignal": true; }; "size": { "alias": "fNodeSize"; "required": false; "isSignal": true; }; "rotate": { "alias": "fNodeRotate"; "required": false; "isSignal": true; }; "fConnectOnNode": { "alias": "fConnectOnNode"; "required": false; "isSignal": true; }; "fMinimapClass": { "alias": "fMinimapClass"; "required": false; "isSignal": true; }; "fDraggingDisabled": { "alias": "fNodeDraggingDisabled"; "required": false; "isSignal": true; }; "fSelectionDisabled": { "alias": "fNodeSelectionDisabled"; "required": false; "isSignal": true; }; "fIncludePadding": { "alias": "fIncludePadding"; "required": false; "isSignal": true; }; "fAutoExpandOnChildHit": { "alias": "fAutoExpandOnChildHit"; "required": false; "isSignal": true; }; "fAutoSizeToFitChildren": { "alias": "fAutoSizeToFitChildren"; "required": false; "isSignal": true; }; }, { "position": "fNodePositionChange"; "sizeChange": "fNodeSizeChange"; "rotate": "fNodeRotateChange"; }, never, never, false, never>;
}

declare function isNode(element: HTMLElement | SVGElement): boolean;

declare const F_NODE_PROVIDERS: (typeof FRotateHandleDirective | typeof FGroupDirective | typeof FNodeDirective)[];

declare class GetNormalizedParentNodeRectRequest {
    readonly nodeOrGroup: FNodeBase;
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup: FNodeBase);
}

declare class GetNormalizedParentNodeRect implements IExecution<GetNormalizedParentNodeRectRequest, IRect> {
    private readonly _store;
    private readonly _mediator;
    handle({ nodeOrGroup }: GetNormalizedParentNodeRectRequest): IRect;
    private _getNode;
    private _getParentRect;
    private _getNodeRect;
    private _getNodePadding;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetNormalizedParentNodeRect, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GetNormalizedParentNodeRect>;
}

declare class IsArrayHasParentNodeRequest {
    fParentNodes: FNodeBase[];
    fDraggedNodes: FNodeBase[];
    static readonly fToken: unique symbol;
    constructor(fParentNodes: FNodeBase[], fDraggedNodes: FNodeBase[]);
}

declare class IsArrayHasParentNode implements IExecution<IsArrayHasParentNodeRequest, boolean> {
    handle(request: IsArrayHasParentNodeRequest): boolean;
    private _getParentNodeIds;
    private _isParentNodeInArray;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsArrayHasParentNode, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IsArrayHasParentNode>;
}

/**
 * @deprecated Use `FNodeConnectionsIntersectionEvent`.
 * Will be removed in a future major release.
 */
declare class FNodeIntersectedWithConnections {
    /** @deprecated Use `nodeId` */
    readonly fNodeId: string;
    /** @deprecated Use `connectionIds` */
    readonly fConnectionIds: string[];
    constructor(
    /** @deprecated Use `nodeId` */
    fNodeId: string, 
    /** @deprecated Use `connectionIds` */
    fConnectionIds: string[]);
}
/**
 * @public API
 * Emitted when a dragged node intersects connections
 * that are not attached to this node.
 */
declare class FNodeConnectionsIntersectionEvent extends FNodeIntersectedWithConnections {
    readonly nodeId: string;
    readonly connectionIds: string[];
    constructor(nodeId: string, connectionIds: string[]);
}

declare class DetectConnectionsUnderDragNodeRequest {
    readonly nodeOrGroup: FNodeBase;
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup: FNodeBase);
}

declare class DetectConnectionsUnderDragNode implements IExecution<DetectConnectionsUnderDragNodeRequest, void> {
    private readonly _mediator;
    private readonly _store;
    handle({ nodeOrGroup }: DetectConnectionsUnderDragNodeRequest): void;
    private _collectConnectableConnectorIds;
    private _collectAttachedConnectionIds;
    private _collectConnectionsUnderNode;
    private _hasIntersection;
    static ɵfac: i0.ɵɵFactoryDeclaration<DetectConnectionsUnderDragNode, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DetectConnectionsUnderDragNode>;
}

interface INodeWithRect {
    node: FNodeBase;
    rect: IRect;
}

declare const DRAG_AND_DROP_COMMON_PROVIDERS: (typeof EmitEndDragSequenceEvent | typeof EmitStartDragSequenceEvent | typeof EmitSelectionChangeEvent | typeof GetNormalizedParentNodeRect | typeof IsArrayHasParentNode | typeof DetectConnectionsUnderDragNode)[];

type TAutoPanMode = 'rebase' | 'direct';
declare function resolveAutoPanMode(kinds: string[]): TAutoPanMode | null;
declare function calculateAutoPanDelta(pointerPosition: IPoint, hostRect: DOMRect, threshold: number, speed: number, acceleration: boolean): IPoint;
declare function calculateAutoPanAxisDelta(pointerCoordinate: number, min: number, max: number, threshold: number, speed: number, acceleration: boolean): number;
declare function rebaseAutoPanPointerDownPosition(position: IPoint, canvasDelta: IPoint, scale: number): Point;

declare class RunAutoPanFrameRequest {
    static readonly fToken: unique symbol;
}

declare class RunAutoPanFrame implements IExecution<RunAutoPanFrameRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragContext;
    handle(_request: RunAutoPanFrameRequest): void;
    private _applyCanvasDelta;
    private _replayLastPointerMove;
    private _getPointerPositionInCanvas;
    private _canAutoPan;
    private _getAutoPanMode;
    private _getAutoPanDelta;
    private _edgeThreshold;
    private _speed;
    private _acceleration;
    private _autoPan;
    static ɵfac: i0.ɵɵFactoryDeclaration<RunAutoPanFrame, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RunAutoPanFrame>;
}

declare class ScheduleAutoPanFrameRequest {
    static readonly fToken: unique symbol;
}

declare class ScheduleAutoPanFrame implements IExecution<ScheduleAutoPanFrameRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragContext;
    handle(_request: ScheduleAutoPanFrameRequest): void;
    private _canAutoPan;
    private _hasAutoPanDelta;
    private _getAutoPanDelta;
    private _getAutoPanMode;
    private _edgeThreshold;
    private _speed;
    private _acceleration;
    private _autoPan;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScheduleAutoPanFrame, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ScheduleAutoPanFrame>;
}

declare class StopAutoPanRequest {
    static readonly fToken: unique symbol;
}

declare class StopAutoPan implements IExecution<StopAutoPanRequest, void> {
    private readonly _store;
    private readonly _dragContext;
    handle(_request: StopAutoPanRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StopAutoPan, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StopAutoPan>;
}

declare const DRAG_AUTO_PAN_PROVIDERS: (typeof StopAutoPan | typeof ScheduleAutoPanFrame | typeof RunAutoPanFrame)[];

declare abstract class IPointerEvent {
    private readonly _event;
    private _target?;
    get originalEvent(): MouseEvent | TouchEvent;
    get targetElement(): HTMLElement;
    get touchEvent(): TouchEvent;
    get touches(): TouchList;
    protected constructor(_event: MouseEvent | TouchEvent, _target?: HTMLElement | undefined);
    setTarget(target: HTMLElement): void;
    abstract isMouseLeftButton(): boolean;
    abstract isMouseRightButton(): boolean;
    preventDefault(): void;
    abstract getPosition(): {
        x: number;
        y: number;
    };
    get isEventInLockedContext(): boolean;
}

declare class IMouseEvent extends IPointerEvent {
    constructor(event: MouseEvent, target?: HTMLElement);
    isMouseLeftButton(): boolean;
    isMouseRightButton(): boolean;
    getPosition(): {
        x: number;
        y: number;
    };
}

declare class IPointerUpEvent extends IPointerEvent {
    constructor(event: PointerEvent, target?: HTMLElement);
    isMouseLeftButton(): boolean;
    isMouseRightButton(): boolean;
    getPosition(): {
        x: number;
        y: number;
    };
    getPointerType(): string;
    getPointerId(): number;
}

declare class ITouchDownEvent extends IPointerEvent {
    constructor(event: TouchEvent);
    isMouseLeftButton(): boolean;
    isMouseRightButton(): boolean;
    getPosition(): {
        x: number;
        y: number;
    };
}

declare class ITouchMoveEvent extends IPointerEvent {
    constructor(event: TouchEvent, target?: HTMLElement);
    isMouseLeftButton(): boolean;
    isMouseRightButton(): boolean;
    getPosition(): {
        x: number;
        y: number;
    };
}

declare const MOUSE_EVENT_IGNORE_TIME = 800;
/**
 * Base class for implementing drag and drop functionality.
 * It handles mouse and touch events, manages the drag start sequence,
 * and provides abstract methods for derived classes to implement specific behaviors.
 */
declare abstract class DragAndDropBase {
    private readonly _document;
    private readonly _ngZone;
    private _mouseListeners;
    private _touchListeners;
    private _startListeners;
    isSyntheticEvent(_event: MouseEvent): boolean;
    private _lastTouchEventTime;
    isDragStarted: boolean;
    private _dragStartThreshold;
    private _dragStartDelay;
    private _dragStartTime;
    private _dragStartPosition;
    abstract disabled: boolean;
    private _moveHandler;
    private _pointerDownElement;
    /**
     * Handles the mouse down event to initiate the drag sequence.
     * It checks if the event is synthetic or fake, and if the drag is already started.
     * If not, it sets up the drag start sequence by adding necessary event listeners.
     * @param event - The mouse event that triggered the drag.
     */
    private _onMouseDown;
    /**
     * Handles the touch down event to initiate the drag sequence.
     * It checks if the event is synthetic or fake, and if the drag is already started.
     * If not, it sets up the drag start sequence by adding necessary event listeners.
     * @param event - The touch event that triggered the drag.
     */
    private _onTouchDown;
    /**
     * Handles the select start event.
     * This method is called when the user starts selecting text or elements.
     * It prevents the default behavior and calls the onSelect method to handle the selection.
     * @param event - The event that triggered the select start.
     */
    private _onSelectStart;
    /**
     * Handles the mouse move event during the drag sequence.
     * It checks if the drag sequence should start and calls the move handler accordingly.
     * @param event - The mouse event that triggered the move.
     */
    private _onMouseMove;
    /**
     * Handles the touch move event during the drag sequence.
     * It checks if the drag sequence should start and calls the move handler accordingly.
     * @param event - The touch event that triggered the move.
     */
    private _onTouchMove;
    /**
     * Checks if the drag sequence should start based on the pointer position.
     * It compares the current pointer position with the initial drag start position
     * and checks if the distance exceeds the drag start threshold.
     * If the threshold is exceeded and the delay has passed,
     * it prepares the drag sequence and sets the move handler to onPointerMove.
     * @param event - The pointer event that triggered the check.
     */
    private _checkDragSequenceToStart;
    /**
     * Prepares the drag sequence by setting up necessary event listeners
     * and initializing any required state for the drag operation.
     * This method should be implemented by derived classes to define specific drag behavior.
     * @param event - The pointer event that triggered the preparation.
     */
    protected abstract prepareDragSequence(event: IPointerEvent): void;
    /**
     * Handles the pointer up event at the end of the drag sequence.
     * It checks if the drag has started and calls the onPointerUp method.
     * It also ends the drag sequence by resetting the state and removing event listeners.
     * This method is called when the user releases the mouse button or lifts their finger from the touch screen.
     * @param event - The pointer event that triggered the up action.
     */
    private _onPointerUpEvent;
    /**
     * Ends the drag sequence by resetting the state and removing event listeners.
     * It sets the isDragStarted flag to false, clears the pointerDownElement,
     * and resets the moveHandler to checkDragSequenceToStart.
     * It also removes all mouse and touch event listeners that were added during the drag sequence.
     */
    private _endDragSequence;
    protected abstract finalizeDragSequence(): void;
    protected abstract onSelect(event: Event): void;
    protected abstract onPointerDown(event: IPointerEvent): boolean;
    protected abstract onPointerMove(event: IPointerEvent): void;
    protected abstract onPointerUp(event: IPointerEvent): void;
    protected subscribe(): void;
    protected unsubscribe(): void;
    private _listen;
    private _unlisten;
    private _preventDuringDrag;
}

declare class FDragStartedEvent<TData = unknown> {
    /** New identifier (can differ from legacy). */
    readonly kind: string;
    /** Payload. */
    readonly data?: TData;
    /**
     * Legacy identifier.
     * Kept as own property to preserve Object.keys / hasOwnProperty / spread behavior.
     * @deprecated Use `kind`
     */
    readonly fEventType: string;
    /** @deprecated Use `data` */
    get fData(): TData | undefined;
    constructor(kind: string, data?: TData, legacyKind?: string);
}

interface IDragSessionFeature {
    onPrepare?(ctx: IDragSessionContext): void;
    onMove?(ctx: IDragSessionContext, delta: IPoint): void;
    onFinalize?(ctx: IDragSessionContext, delta: IPoint): void;
    onEnd?(ctx: IDragSessionContext): void;
}
interface IDragSessionContext {
    flowHost: HTMLElement;
    transform: ITransformModel;
    getDraggedUnionRect(delta: IPoint): IRect;
}

declare abstract class DragHandlerBase<TData> {
    protected abstract readonly type: string;
    protected abstract readonly kind: string;
    protected data(): TData | undefined;
    private readonly _features;
    getEvent(): FDragStartedEvent<TData>;
    attachFeature(feature: IDragSessionFeature): void;
    protected featuresPrepare(ctx: IDragSessionContext): void;
    protected featuresMove(ctx: IDragSessionContext, delta: IPoint): void;
    protected featuresFinalize(ctx: IDragSessionContext, delta: IPoint): void;
    protected featuresEnd(ctx: IDragSessionContext): void;
    prepareDragSequence?(): void;
    abstract onPointerMove(difference: IPoint, event?: IPointerEvent): void;
    onPointerUp?(): void;
    destroy?(): void;
}

type NoArgsCtor<T> = new () => T;
interface IDestroyable {
    destroy(): void;
}
declare class DragHandlerInjector {
    private readonly _injector;
    private _dragInjector;
    private _created;
    create(): void;
    get<T>(token: ProviderToken<T>): T;
    createInstance<T>(ctor: NoArgsCtor<T>): T;
    destroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragHandlerInjector, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragHandlerInjector>;
}

declare class EventExtensions {
    private static _isSupported;
    private static _isPassiveEventListenerSupported;
    private static _passiveEventListener;
    static activeListener(): boolean | AddEventListenerOptions;
    static passiveListener(): boolean | AddEventListenerOptions;
    static activeCaptureListener(): boolean | AddEventListenerOptions;
    static emptyListener(): () => void;
}

declare class FDragHandlerResult<T> {
    private _data;
    setData(data: Partial<T>): void;
    getData(): T;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FDragHandlerResult<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FDragHandlerResult<any>>;
}

declare class DragCanvasFinalizeRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class DragCanvasFinalize implements IExecution<DragCanvasFinalizeRequest, void> {
    private readonly _dragContext;
    handle(_request: DragCanvasFinalizeRequest): void;
    private _isValid;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragCanvasFinalize, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragCanvasFinalize>;
}

declare class DragCanvasHandler extends DragHandlerBase<unknown> {
    protected readonly type = "canvas-move";
    protected readonly kind = "drag-canvas";
    private readonly _store;
    private _onPointerDownPosition;
    constructor();
    prepareDragSequence(): void;
    onPointerMove(difference: IPoint): void;
    onPointerUp(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragCanvasHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragCanvasHandler>;
}

declare class DragCanvasPreparationRequest {
    readonly event: IPointerEvent;
    readonly fTrigger: FEventTrigger;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
}

declare class DragCanvasPreparation implements IExecution<DragCanvasPreparationRequest, void> {
    private readonly _store;
    private readonly _dragContext;
    private readonly _dragInjector;
    handle({ event, fTrigger }: DragCanvasPreparationRequest): void;
    private _isValid;
    private _isBackgroundElement;
    private _isDragOnHost;
    private _getNode;
    private _isValidTrigger;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragCanvasPreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragCanvasPreparation>;
}

declare const DRAG_CANVAS_PROVIDERS: (typeof DragCanvasFinalize | typeof DragCanvasPreparation)[];

declare class ExternalRectConstraint {
    private _onPointerDown;
    private readonly _limit;
    private readonly _vCellSize;
    private readonly _hCellSize;
    private readonly _adjustCellSize;
    constructor(injector: Injector, _onPointerDown: IPoint, _limit: IMinMaxPoint);
    limit(difference: IPoint): IPoint;
    private _cellSizeStrategies;
    private _applyCellSize;
    private _skipCellSize;
    private _clamp;
    private _snapToGrid;
}

declare const F_EXTERNAL_ITEM: InjectionToken<FExternalItemBase<any>>;
declare abstract class FExternalItemBase<TData = any> {
    readonly hostElement: any;
    abstract externalItemId: Signal<string>;
    abstract data: Signal<TData | undefined>;
    abstract disabled: Signal<boolean>;
    abstract preview: ModelSignal<TemplateRef<unknown> | undefined>;
    abstract previewMatchSize: Signal<boolean>;
    abstract placeholder: ModelSignal<TemplateRef<unknown> | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemBase<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemBase<any>, never, never, {}, {}, never, never, true, never>;
}

declare class FExternalItem<TData> extends FExternalItemBase<TData> implements OnInit, OnDestroy {
    private readonly _apiService;
    /** Stable id for matching drag sessions, lookups, etc. */
    readonly externalItemId: i0.InputSignal<string>;
    /** Payload attached to external item. */
    readonly data: i0.InputSignal<TData | undefined>;
    /** Disables dragging/interaction. */
    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
    /** Template shown while item is dragged (preview). */
    readonly preview: i0.ModelSignal<TemplateRef<unknown> | undefined>;
    /** Whether preview should match original element size. */
    readonly previewMatchSize: i0.InputSignalWithTransform<boolean, unknown>;
    /** Placeholder template that stays in original place while dragging. */
    readonly placeholder: i0.ModelSignal<TemplateRef<unknown> | undefined>;
    ngOnInit(): void;
    private _disablePointerEvents;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItem<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItem<any>, "[fExternalItem]", never, { "externalItemId": { "alias": "fExternalItemId"; "required": false; "isSignal": true; }; "data": { "alias": "fData"; "required": false; "isSignal": true; }; "disabled": { "alias": "fDisabled"; "required": false; "isSignal": true; }; "preview": { "alias": "fPreview"; "required": false; "isSignal": true; }; "previewMatchSize": { "alias": "fPreviewMatchSize"; "required": false; "isSignal": true; }; "placeholder": { "alias": "fPlaceholder"; "required": false; "isSignal": true; }; }, { "preview": "fPreviewChange"; "placeholder": "fPlaceholderChange"; }, never, never, true, never>;
}

declare class FExternalItemService {
    private readonly _byHost;
    private readonly _items;
    /** Reactive list (internal consumers) */
    readonly items: i0.Signal<readonly FExternalItemBase<any>[]>;
    /** lookup by element (supports passing a nested child) */
    getByElement(el: HTMLElement | SVGElement): FExternalItemBase | undefined;
    /** lookup by host */
    getByHost(host: HTMLElement | SVGElement): FExternalItemBase | undefined;
    register(item: FExternalItemBase): void;
    remove(item: FExternalItemBase): void;
    private _sync;
    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FExternalItemService>;
}

declare class FExternalItemPlaceholder<T = unknown> implements OnInit, OnDestroy {
    private readonly _instance;
    private readonly _templateRef;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemPlaceholder<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemPlaceholder<any>, "ng-template[fExternalItemPlaceholder]", never, {}, {}, never, never, true, never>;
}

declare class FExternalItemPreview<T = unknown> implements OnInit, OnDestroy {
    private readonly _instance;
    private readonly _templateRef;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemPreview<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemPreview<any>, "ng-template[fExternalItemPreview]", never, {}, {}, never, never, true, never>;
}

declare function isExternalItem(element: HTMLElement | SVGElement): boolean;
declare function getExternalItemHost(element: HTMLElement | SVGElement): HTMLElement | SVGElement;

declare const F_EXTERNAL_ITEM_PROVIDERS: (typeof FExternalItem)[];

declare class DragExternalItemCreatePlaceholderRequest {
    readonly externalItem: FExternalItemBase;
    static readonly fToken: unique symbol;
    constructor(externalItem: FExternalItemBase);
}

declare class DragExternalItemCreatePlaceholder implements IExecution<DragExternalItemCreatePlaceholderRequest, HTMLElement | SVGElement> {
    private readonly _browser;
    private readonly _containerRef;
    handle({ externalItem, }: DragExternalItemCreatePlaceholderRequest): HTMLElement | SVGElement;
    private _fromTemplate;
    private _fromHost;
    private _createViewRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragExternalItemCreatePlaceholder, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragExternalItemCreatePlaceholder>;
}

declare class DragExternalItemCreatePreviewRequest {
    readonly externalItem: FExternalItemBase;
    static readonly fToken: unique symbol;
    constructor(externalItem: FExternalItemBase);
}

declare class DragExternalItemCreatePreview implements IExecution<DragExternalItemCreatePreviewRequest, HTMLElement | SVGElement> {
    private readonly _browser;
    private readonly _containerRef;
    handle({ externalItem }: DragExternalItemCreatePreviewRequest): HTMLElement | SVGElement;
    private _fromTemplate;
    private _fromHost;
    private _createViewRef;
    private _setPreviewStyles;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragExternalItemCreatePreview, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragExternalItemCreatePreview>;
}

declare class DragExternalItemFinalizeRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class DragExternalItemFinalize implements IExecution<DragExternalItemFinalizeRequest, void> {
    private readonly _result;
    private readonly _mediator;
    private readonly _store;
    private readonly _dragSession;
    private readonly _browser;
    private get _createNodeEmitter();
    handle(request: DragExternalItemFinalizeRequest): void;
    private _findExternalItemHandler;
    private _getDestinationNodeOrGroupId;
    private _getDropToGroupHandler;
    private _getElementsFromPoint;
    private _emitEvent;
    private _isPointerInCanvasRect;
    private _getPreviewRect;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragExternalItemFinalize, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragExternalItemFinalize>;
}

declare class FDragExternalItemStartEventData<T> {
    readonly data: T;
    constructor(data: T);
}

declare class DragExternalItemHandler extends DragHandlerBase<unknown> {
    private readonly _externalItem;
    private readonly _pointerDownClientPosition;
    protected readonly type = "external-item";
    protected readonly kind = "drag-external-item";
    protected data(): FDragExternalItemStartEventData<unknown>;
    private readonly _result;
    private readonly _mediator;
    private readonly _browser;
    private readonly _store;
    private _previewEl?;
    private _placeholderEl?;
    private _startRect;
    private _pointerDownRect;
    private _absoluteOffsetFromFlow;
    private _grabOffsetFromPointer;
    private _originalParent?;
    private _originalNextSibling?;
    private readonly _originalDisplay;
    private _applyConstraints;
    constructor(injector: Injector, _externalItem: FExternalItemBase<unknown>, _pointerDownClientPosition: IPoint);
    private get _host();
    /** Overlay root: fullscreenElement (if any) or document.body */
    private get _overlayRoot();
    private get _transform();
    private _initConstraints;
    private _getStartRect;
    prepareDragSequence(): void;
    private _rememberOriginalPlacement;
    private _createPreview;
    private _createPlaceholder;
    private _placePreviewIntoOverlay;
    private _swapOriginalWithPlaceholderAndMoveOriginalIntoOverlay;
    onPointerMove(delta: IPoint, event?: IPointerEvent): void;
    onPointerUp(): void;
    private _restoreOriginalInParent;
    private _matchSize;
    private _readAbsoluteRect;
    private _toAbsolutePoint;
    private _resolveDeltaFromPointer;
    private _toFlowPoint;
    private _getFlowHostAbsolutePosition;
    private _clientToAbsolute;
}

declare class DragExternalItemPreparationRequest {
    readonly event: IPointerEvent;
    readonly fTrigger: FEventTrigger;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
}

declare class DragExternalItemPreparation implements IExecution<DragExternalItemPreparationRequest, void> {
    private readonly _apiService;
    private readonly _dragSession;
    private readonly _store;
    private readonly _injector;
    private get _flowHost();
    private get _transform();
    handle({ event, fTrigger }: DragExternalItemPreparationRequest): void;
    private _resolveExternalItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragExternalItemPreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragExternalItemPreparation>;
}

declare class PreventDefaultIsExternalItemRequest {
    readonly event: Event;
    static readonly fToken: unique symbol;
    constructor(event: Event);
}

declare class PreventDefaultIsExternalItem implements IExecution<PreventDefaultIsExternalItemRequest, void> {
    handle(request: PreventDefaultIsExternalItemRequest): void;
    private _isTargetItemExternal;
    private _isExternalItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<PreventDefaultIsExternalItem, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PreventDefaultIsExternalItem>;
}

declare class FCreateNodeEvent<TData = any> {
    /** Rect of the dragged external item at the moment of drop (in flow coordinates). */
    readonly externalItemRect: IRect;
    /** External item data payload. */
    readonly data: TData;
    /** Id of node/group where item was dropped (if any). */
    readonly targetContainerId?: string;
    /** Pointer drop position in flow coordinates (if provided). */
    readonly dropPosition?: IPoint;
    /** @deprecated Use `externalItemRect` */
    readonly rect: IRect;
    /** @deprecated Use `targetContainerId` */
    readonly fTargetNode?: string;
    /** @deprecated Use `dropPosition` */
    readonly fDropPosition?: IPoint;
    constructor(externalItemRect: IRect, data: TData, targetContainerId?: string, dropPosition?: IPoint);
}

interface IDragExternalItemDragResult {
    preview: HTMLElement | SVGElement;
    externalItem: FExternalItemBase<unknown>;
}

declare const DRAG_EXTERNAL_ITEM_HANDLER_TYPE = "external-item";
declare const DRAG_EXTERNAL_ITEM_HANDLER_KIND = "drag-external-item";
declare function isDragExternalItemHandler(value: DragHandlerBase<unknown>): value is DragExternalItemHandler;

declare const DRAG_EXTERNAL_ITEM_PROVIDERS: (typeof DragExternalItemCreatePlaceholder | typeof DragExternalItemCreatePreview | typeof DragExternalItemFinalize | typeof DragExternalItemPreparation | typeof PreventDefaultIsExternalItem)[];

declare class CalculateFlowPointFromMinimapPointRequest {
    readonly flowRect: IRect;
    readonly canvasPosition: IPoint;
    readonly eventPoint: IPoint;
    readonly minimap: FMinimapState;
    static readonly fToken: unique symbol;
    constructor(flowRect: IRect, canvasPosition: IPoint, eventPoint: IPoint, minimap: FMinimapState);
}

declare class CalculateFlowPointFromMinimapPoint implements IExecution<CalculateFlowPointFromMinimapPointRequest, IPoint> {
    private readonly _store;
    private get _canvasScale();
    handle(payload: CalculateFlowPointFromMinimapPointRequest): IPoint;
    private _getNormalizedFlowCenter;
    private _getPositionInViewBox;
    normalizeEventPoint(point: IPoint, minimap: FMinimapState): Point;
    private _getEventPointInMinimap;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateFlowPointFromMinimapPoint, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateFlowPointFromMinimapPoint>;
}

declare class DragMinimapFinalizeRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class DragMinimapFinalize implements IExecution<DragMinimapFinalizeRequest, void> {
    private readonly _dragSession;
    handle(_request: DragMinimapFinalizeRequest): void;
    private _isValid;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragMinimapFinalize, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragMinimapFinalize>;
}

declare class DragMinimapHandler extends DragHandlerBase<unknown> {
    protected readonly type = "minimap";
    protected readonly kind = "minimap";
    private readonly _store;
    private readonly _mediator;
    private _lastDelta;
    private _flowRect;
    private _startCanvasPosition;
    private _eventPoint;
    private _minimap;
    initialize(flowRect: IRect, startCanvasPosition: IPoint, eventPoint: IPoint, minimap: FMinimapState): void;
    prepareDragSequence(): void;
    onPointerMove(delta: IPoint): void;
    private _isSamePoint;
    private _getNewPosition;
    onPointerUp(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragMinimapHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragMinimapHandler>;
}

declare class DragMinimapPreparationRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class DragMinimapPreparation implements IExecution<DragMinimapPreparationRequest, void> {
    private readonly _store;
    private readonly _mediator;
    private readonly _dragSession;
    private readonly _dragInjector;
    private get _canvas();
    private get _flowHost();
    handle({ event }: DragMinimapPreparationRequest): void;
    private _isValid;
    private _calculateCanvasPosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragMinimapPreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragMinimapPreparation>;
}

declare const DRAG_MINIMAP_HANDLER_TYPE = "minimap";
declare const DRAG_MINIMAP_HANDLER_KIND = "minimap";
declare function isDragMinimapHandler(value: DragHandlerBase<unknown>): value is DragMinimapHandler;

declare const DRAG_MINIMAP_PROVIDERS: (typeof CalculateFlowPointFromMinimapPoint | typeof DragMinimapFinalize | typeof DragMinimapPreparation)[];

declare class CreateConnectionFinalizeRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class CreateConnectionFinalize implements IHandler<CreateConnectionFinalizeRequest, void> {
    private readonly _result;
    private readonly _mediator;
    private readonly _store;
    private readonly _dragContext;
    private get _dragHandler();
    handle(request: CreateConnectionFinalizeRequest): void;
    private _isValid;
    private _getTargetOutput;
    private _getOutput;
    private _getOutlet;
    private _emitEvent;
    private _getInputUnderPointer;
    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionFinalize, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionFinalize>;
}

declare class CreateConnectionCreateDragHandlerRequest {
    readonly eventPosition: IPoint;
    readonly source: FNodeOutputBase | FNodeOutletBase;
    static readonly fToken: unique symbol;
    constructor(eventPosition: IPoint, source: FNodeOutputBase | FNodeOutletBase);
}

declare class CreateConnectionCreateDragHandler implements IHandler<CreateConnectionCreateDragHandlerRequest, void> {
    private readonly _store;
    private readonly _dragContext;
    private readonly _dragInjector;
    private get _transform();
    handle({ source, eventPosition }: CreateConnectionCreateDragHandlerRequest): void;
    /**
     * Converts raw pointer position to "flow host space":
     * - applies elementTransform(flowHost)
     * - normalizes by scale
     */
    private _toFlowSpace;
    /**
     * Converts from flow space to "canvas local space":
     * - removes transform offsets (position, scaledPosition)
     * - keeps normalization consistent
     *
     * (Same math as your original chain, just named.)
     */
    private _toCanvasSpace;
    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionCreateDragHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionCreateDragHandler>;
}

declare class CreateConnectionFromOutletPreparationRequest {
    readonly event: IPointerEvent;
    readonly node: FNodeBase;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent, node: FNodeBase);
}

declare class CreateConnectionFromOutletPreparation implements IHandler<CreateConnectionFromOutletPreparationRequest, void> {
    private readonly _mediator;
    private readonly _store;
    handle({ event, node }: CreateConnectionFromOutletPreparationRequest): void;
    private _findOutlet;
    private _getOutputs;
    private _resolveOutput;
    private _startDrag;
    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionFromOutletPreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionFromOutletPreparation>;
}

declare class CreateConnectionFromOutputPreparationRequest {
    readonly event: IPointerEvent;
    readonly node: FNodeBase;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent, node: FNodeBase);
}

declare class CreateConnectionFromOutputPreparation implements IHandler<CreateConnectionFromOutputPreparationRequest, void> {
    private readonly _mediator;
    private readonly _store;
    handle({ event, node }: CreateConnectionFromOutputPreparationRequest): void;
    private _hasOutlet;
    private _findOutput;
    private _startDrag;
    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionFromOutputPreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionFromOutputPreparation>;
}

declare class CreateConnectionPreparationRequest {
    readonly event: IPointerEvent;
    readonly fTrigger: FEventTrigger;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
}

declare class CreateConnectionPreparation implements IHandler<CreateConnectionPreparationRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragContext;
    handle({ event, fTrigger }: CreateConnectionPreparationRequest): void;
    private _findOwnerNode;
    private _isValidConditions;
    private _isValidTrigger;
    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionPreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionPreparation>;
}

declare class ResolveConnectableOutputForOutletRequest {
    readonly outlet: FNodeOutletBase;
    static readonly fToken: unique symbol;
    constructor(outlet: FNodeOutletBase);
}

declare class ResolveConnectableOutputForOutlet implements IHandler<ResolveConnectableOutputForOutletRequest, FConnectorBase | undefined> {
    private readonly _store;
    handle({ outlet }: ResolveConnectableOutputForOutletRequest): FConnectorBase | undefined;
    private _findOwnerNode;
    private _findFirstConnectableOutputInNode;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResolveConnectableOutputForOutlet, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResolveConnectableOutputForOutlet>;
}

interface ICreateConnectionEventData {
    fOutputOrOutletId: string;
}

type FSourceConnector = FNodeOutputBase | FNodeOutletBase;
declare class CreateConnectionHandler extends DragHandlerBase<ICreateConnectionEventData> {
    protected readonly type = "create-connection";
    protected readonly kind = "create-connection";
    protected data(): {
        fOutputOrOutletId: string;
    };
    private readonly _result;
    private readonly _mediator;
    private readonly _connectionBehaviour;
    private readonly _store;
    private get _connection();
    private get _snapConnection();
    private _targets;
    private _sourceRef;
    private _pointerDown;
    initialize(source: FSourceConnector, pointer: IPoint): void;
    prepareDragSequence(): void;
    private _collectAndMarkTargets;
    private _initSnapConnection;
    private _initCreateConnection;
    onPointerMove(difference: IPoint): void;
    private _findClosestTarget;
    private _drawCreateConnection;
    private _drawSnapConnection;
    onPointerUp(): void;
    private _resolveRotationContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<CreateConnectionHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CreateConnectionHandler>;
}

declare class FCreateConnectionEvent {
    /** Source connector id */
    readonly sourceId: string;
    /** Target connector id (can be undefined if dropped to nowhere) */
    readonly targetId: string | undefined;
    /** Pointer position where the user dropped pointer. */
    readonly dropPosition: IPoint;
    /** @deprecated Use `sourceId` */
    readonly fOutputId: string;
    /** @deprecated Use `targetId` */
    readonly fInputId: string | undefined;
    /** @deprecated Use `dropPosition` */
    readonly fDropPosition: IPoint;
    constructor(sourceId: string, targetId: string | undefined, dropPosition: IPoint);
}

interface ICreateConnectionDragResult {
    toConnectorRect: RoundedRect;
    fOutputId: string;
    canBeConnectedInputs: IConnectorRectRef[];
}

declare class ReassignConnectionFinalizeRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class ReassignConnectionFinalize implements IExecution<ReassignConnectionFinalizeRequest, void> {
    private readonly _dragResult;
    private readonly _mediator;
    private readonly _store;
    private readonly _dragContext;
    private get _dragDirective();
    handle({ event }: ReassignConnectionFinalizeRequest): void;
    private _findReassignHandler;
    private _emitIfChanged;
    private _findConnectableConnector;
    private _isReassignedToDifferentConnector;
    private _buildEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReassignConnectionFinalize, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ReassignConnectionFinalize>;
}

declare class ReassignConnectionPreparationRequest {
    readonly event: IPointerEvent;
    readonly fTrigger: FEventTrigger;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
}

declare class ReassignConnectionPreparation implements IExecution<ReassignConnectionPreparationRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragContext;
    private readonly _dragInjector;
    private get _canvas();
    private get _transform();
    private get _connections();
    handle(request: ReassignConnectionPreparationRequest): void;
    private _findConnectionAt;
    private _capturePointerDown;
    private _startDrag;
    private _isValidTrigger;
    private _bringToFront;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReassignConnectionPreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ReassignConnectionPreparation>;
}

declare function isPointerInsideStartOrEndDragHandles(connection: FConnectionBase, position: IPoint): boolean;
declare function isDragHandleEnd(connection: FConnectionBase, position: IPoint): boolean;
declare function isDragHandleStart(connection: FConnectionBase, position: IPoint): boolean;

interface IReassignHandler {
    /** List used by finalize step to find the closest candidate connector. */
    candidates(): IConnectorRectRef[];
    /** Collects candidates and marks them in UI. */
    collectAndMarkCandidates(): void;
    /** Optional snap connection preview. */
    setSnapConnection(snap: FSnapConnectionComponent | undefined): void;
    onPointerMove(difference: IPoint): void;
    onPointerUp(): void;
}
declare function withinSnapThreshold(fClosestConnector: IClosestConnectorRef | undefined, snapConnection: FSnapConnectionComponent): IClosestConnectorRef | undefined;
declare function rectFromPoint(point: IPoint): RoundedRect;

declare class ReassignConnectionSourceHandler implements IReassignHandler {
    private readonly _mediator;
    private readonly _behaviour;
    private readonly _connection;
    private readonly _sourceRef;
    private readonly _targetRef;
    private _candidates;
    private _snap;
    private readonly _anchorRect;
    private get _source();
    private get _target();
    constructor(_mediator: FMediator, _behaviour: ConnectionBehaviourBuilder, _connection: FConnectionBase, _sourceRef: IConnectorRectRef, _targetRef: IConnectorRectRef);
    candidates(): IConnectorRectRef[];
    collectAndMarkCandidates(): void;
    setSnapConnection(snap: FSnapConnectionComponent | undefined): void;
    onPointerMove(difference: IPoint): void;
    private _findClosest;
    private _draw;
    private _drawSnap;
    onPointerUp(): void;
    private _resolveRotationContext;
}

declare class ReassignConnectionTargetHandler implements IReassignHandler {
    private readonly _mediator;
    private readonly _behaviour;
    private readonly _connection;
    private readonly _sourceRef;
    private readonly _targetRef;
    private _candidates;
    private _snap;
    private readonly _anchorRect;
    private get _source();
    private get _target();
    constructor(_mediator: FMediator, _behaviour: ConnectionBehaviourBuilder, _connection: FConnectionBase, _sourceRef: IConnectorRectRef, _targetRef: IConnectorRectRef);
    candidates(): IConnectorRectRef[];
    collectAndMarkCandidates(): void;
    setSnapConnection(snap: FSnapConnectionComponent | undefined): void;
    onPointerMove(difference: IPoint): void;
    onPointerUp(): void;
    private _findClosest;
    private _draw;
    private _drawSnap;
    private _resolveRotationContext;
}

interface IReassignConnectionEventData {
    fConnectionId: string;
}

declare class ReassignConnectionHandler extends DragHandlerBase<IReassignConnectionEventData> {
    protected readonly type = "reassign-connection";
    protected readonly kind = "reassign-connection";
    protected data(): {
        fConnectionId: string;
    };
    private readonly _result;
    private readonly _mediator;
    private readonly _connectionBehaviour;
    private readonly _store;
    private get _snapConnection();
    private _connection;
    private _draggedEnd;
    private _sourceRef;
    private _targetRef;
    private _reassignHandler;
    initialize(connection: FConnectionBase, isTargetDragHandle: boolean): void;
    private _createSourceHandler;
    private _createTargetHandler;
    prepareDragSequence(): void;
    onPointerMove(difference: IPoint): void;
    onPointerUp(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReassignConnectionHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ReassignConnectionHandler>;
}

type FConnectionEndpoint = 'source' | 'target';
declare class FReassignConnectionEvent {
    readonly connectionId: string;
    /** Which endpoint was reassigned. */
    readonly endpoint: FConnectionEndpoint;
    /** Previous and next ids; `next*Id` can be `undefined` if dropped to nowhere. */
    readonly previousSourceId: string;
    readonly nextSourceId: string | undefined;
    readonly previousTargetId: string;
    readonly nextTargetId: string | undefined;
    /** Pointer position where the user dropped pointer. */
    readonly dropPosition: IPoint;
    /** @deprecated Use `endpoint === 'source'` */
    readonly isSourceReassign: boolean;
    /** @deprecated Use `endpoint === 'target'` */
    readonly isTargetReassign: boolean;
    /** @deprecated Use `previousSourceId` */
    readonly oldSourceId: string;
    /** @deprecated Use `nextSourceId` */
    readonly newSourceId: string | undefined;
    /** @deprecated Use `previousTargetId` */
    readonly oldTargetId: string;
    /** @deprecated Use `nextTargetId` */
    readonly newTargetId: string | undefined;
    /** @deprecated Use `dropPosition` */
    readonly dropPoint: IPoint;
    constructor(connectionId: string, endpoint: FConnectionEndpoint, previousSourceId: string, nextSourceId: string | undefined, previousTargetId: string, nextTargetId: string | undefined, dropPosition: IPoint);
}

interface IReassignConnectionDragResult {
    /** Which handle is being dragged: source(output) or target(input). */
    draggedEnd: 'source' | 'target';
    /**
     * Line endpoints represented as small rects (anchors) so we can use the same math as for connectors.
     * These are NOT connector bounds.
     */
    sourceAnchorRect: RoundedRect;
    targetAnchorRect: RoundedRect;
    /** Connection being reassigned. */
    connection: FConnectionBase;
    /** Candidate connectors that are connectable for this reassignment. */
    candidates: IConnectorRectRef[];
}

declare class DragConnectionWaypointFinalizeRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class DragConnectionWaypointFinalize implements IExecution<DragConnectionWaypointFinalizeRequest, void> {
    private readonly _dragContext;
    private get _fDragHandler();
    handle(_request: DragConnectionWaypointFinalizeRequest): void;
    private _isDroppedConnectionReassignEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragConnectionWaypointFinalize, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragConnectionWaypointFinalize>;
}

declare class DragConnectionWaypointPreparationRequest {
    readonly event: IPointerEvent;
    readonly fTrigger: FEventTrigger;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
}

declare class DragConnectionWaypointPreparation implements IExecution<DragConnectionWaypointPreparationRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragContext;
    private readonly _dragInjector;
    private get _canvas();
    private get _transform();
    private get _flowHost();
    private get _connections();
    handle(request: DragConnectionWaypointPreparationRequest): void;
    private _pickControlPoint;
    private _isValidTrigger;
    private _updateConnectionLayer;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragConnectionWaypointPreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragConnectionWaypointPreparation>;
}

declare class DragConnectionWaypointHandler extends DragHandlerBase<unknown> {
    protected readonly type = "move-connection-waypoint";
    protected readonly kind = "drag-connection-waypoint";
    private readonly _store;
    private _point;
    private _pick;
    private get _waypointsComponent();
    private get _connection();
    setPick(pick: WaypointPick<FConnectionBase>): void;
    prepareDragSequence(): void;
    onPointerMove(_difference: IPoint): void;
    onPointerUp(): void;
    private _redrawConnection;
    private _eventFromPick;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragConnectionWaypointHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragConnectionWaypointHandler>;
}

declare class FConnectionWaypointsChangedEvent {
    readonly connectionId: string;
    readonly waypoints: IPoint[];
    constructor(connectionId: string, waypoints: IPoint[]);
}

declare const DRAG_CONNECTIONS_PROVIDERS: (typeof ResolveConnectableOutputForOutlet | typeof CreateConnectionFinalize | typeof CreateConnectionCreateDragHandler | typeof CreateConnectionFromOutletPreparation | typeof CreateConnectionFromOutputPreparation | typeof CreateConnectionPreparation | typeof ReassignConnectionFinalize | typeof ReassignConnectionPreparation | typeof DragConnectionWaypointFinalize | typeof DragConnectionWaypointPreparation)[];

declare class DropToGroupFinalizeRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class DropToGroupFinalize implements IExecution<DropToGroupFinalizeRequest, void> {
    private readonly _dragSession;
    private readonly _store;
    handle({ event }: DropToGroupFinalizeRequest): void;
    private _findDropHandler;
    private _emitDropToGroupEvent;
    /**
     * Returns only "top-level" dragged items:
     * if a node's parent is also in dragged set, we exclude the child.
     */
    private _getTopLevelDraggedIds;
    private _getMoveSummaryHandler;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropToGroupFinalize, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DropToGroupFinalize>;
}

declare class DropToGroupPreparationRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class DropToGroupPreparation implements IExecution<DropToGroupPreparationRequest, void> {
    private readonly _mediator;
    private readonly _dragContext;
    private readonly _store;
    private readonly _dragInjector;
    private get _allNodes();
    handle({ event }: DropToGroupPreparationRequest): void;
    private _canPrepare;
    private _hasMoveDrag;
    private _hasExternalDrag;
    private _sortedTargetsForDrop;
    private _getDraggedNodes;
    private _withParents;
    private _eligibleTargets;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropToGroupPreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DropToGroupPreparation>;
}

declare class DropToGroupHandler extends DragHandlerBase<unknown> {
    /** Legacy identifier (external compatibility). */
    protected readonly type = "move-node-to-parent";
    /** New identifier. */
    protected readonly kind = "assign-to-container";
    private readonly _store;
    private readonly _dragSession;
    private get _transform();
    private _candidateGroups;
    private _debounceTimer;
    private _activeTarget;
    /** Read-only access for finalize stage. */
    get activeTarget(): INodeWithRect | null;
    initialize(candidateGroups: INodeWithRect[]): void;
    prepareDragSequence(): void;
    onPointerMove(difference: IPoint): void;
    onPointerUp(): void;
    private _updateActiveTarget;
    private _getPointerInFlow;
    private _findTargetUnderPointer;
    private _setActiveTarget;
    private _clearActiveTarget;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropToGroupHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DropToGroupHandler>;
}

declare class SortDropCandidatesByLayerRequest {
    readonly candidates: INodeWithRect[];
    static readonly fToken: unique symbol;
    constructor(candidates: INodeWithRect[]);
}

declare class SortDropCandidatesByLayer implements IExecution<SortDropCandidatesByLayerRequest, INodeWithRect[]> {
    handle({ candidates }: SortDropCandidatesByLayerRequest): INodeWithRect[];
    private _compareDomOrder;
    static ɵfac: i0.ɵɵFactoryDeclaration<SortDropCandidatesByLayer, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SortDropCandidatesByLayer>;
}

declare class FDropToGroupEvent {
    /** Preferred name: Group (target) id */
    readonly targetGroupId: string;
    /** Preferred name: Dropped node ids */
    readonly nodeIds: string[];
    /** Preferred name: Pointer drop position */
    readonly dropPosition: IPoint;
    /** @deprecated Use `targetGroupId` */
    readonly fTargetNode: string;
    /** @deprecated Use `nodeIds` */
    readonly fNodes: string[];
    /** @deprecated Use `dropPosition` */
    readonly fDropPosition: IPoint;
    constructor(targetGroupId: string, nodeIds: string[], dropPosition: IPoint);
}

declare const DRAG_DROP_TO_GROUP_PROVIDERS: (typeof DropToGroupFinalize | typeof SortDropCandidatesByLayer | typeof DropToGroupPreparation)[];

declare class CreateDragNodeHierarchyRequest {
    readonly nodesAndGroups: FNodeBase[];
    static readonly fToken: unique symbol;
    /** Selected nodes and groups including their deep children. */
    constructor(nodesAndGroups: FNodeBase[]);
}

interface IConstraintEdges {
    left: boolean;
    right: boolean;
    top: boolean;
    bottom: boolean;
}
interface IDeltaClampResult {
    value: IPoint;
    overflow: IPoint;
    edges: IConstraintEdges;
}
declare class DeltaClamp {
    private readonly _limits;
    private readonly _quantizeStep;
    constructor(_limits: IMinMaxPoint, _quantizeStep?: number);
    applyInto(offset: IPoint, out: IDeltaClampResult): void;
    private _quantizeSigned;
    private _clamp;
}

interface IDragNodeDeltaConstraintsResult {
    /** Delta after snap + hard clamp */
    hardDelta: IPoint;
    /** Per-soft-constraint overflow based on hardDelta */
    soft: IDeltaClampResult[];
}

interface IDragNodeSoftConstraint {
    nodeOrGroup: FNodeBase;
    boundingRect: IRect;
    initialSize: ISize | undefined;
    limits: IMinMaxPoint;
}
interface IDragNodeDeltaConstraints {
    hard: IMinMaxPoint;
    soft: IDragNodeSoftConstraint[];
}

declare class DragNodeDeltaConstraints {
    private readonly _snapper;
    private readonly _hardClamp;
    private readonly _hardResult;
    private readonly _softClamps;
    private readonly _softResults;
    constructor(injector: Injector, pointerDown: IPoint, limits: IDragNodeDeltaConstraints);
    apply(delta: IPoint, forceSnap?: boolean): IDragNodeDeltaConstraintsResult;
    finalize(delta: IPoint): IDragNodeDeltaConstraintsResult;
}

declare function expandRectByOverflow(baselineRect: IRect, overflowDelta: IPoint, edges: IConstraintEdges): IRect;

declare class GridSnapper {
    private readonly _pointerDown;
    private readonly _vCellSize;
    private readonly _hCellSize;
    private readonly _snapWhileDragging;
    constructor(data: {
        vCellSize: Signal<number>;
        hCellSize: Signal<number>;
        fCellSizeWhileDragging: Signal<boolean>;
    }, _pointerDown: IPoint);
    snap(difference: IPoint, adjustCellSize: boolean): IPoint;
    private _strategies;
    private _snapWithCellSize;
    private _noSnap;
    private _snapToGrid;
}

declare class DragNodeConnectionHandlerBase {
    private readonly _mediator;
    private readonly _store;
    private readonly _behaviour;
    private _source;
    private _target;
    private _sourceRef;
    private _targetRef;
    private _sourceDelta;
    private _targetDelta;
    connection: FConnectionBase;
    initialize(connection: FConnectionBase): void;
    setSourceDelta(delta: IPoint): void;
    setTargetDelta(delta: IPoint): void;
    protected redraw(): void;
    private _buildLine;
    private _readRectRef;
    private _withDelta;
    private _resolveRotationContext;
}

declare class DragNodeConnectionSourceHandler extends DragNodeConnectionHandlerBase {
    setSourceDelta(delta: IPoint): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragNodeConnectionSourceHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragNodeConnectionSourceHandler>;
}

declare class DragNodeConnectionBothSidesHandler extends DragNodeConnectionHandlerBase {
    private _sourceUpdated;
    private _targetUpdated;
    setSourceDelta(delta: IPoint): void;
    setTargetDelta(delta: IPoint): void;
    private _redrawIfReady;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragNodeConnectionBothSidesHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragNodeConnectionBothSidesHandler>;
}

declare class DragNodeConnectionTargetHandler extends DragNodeConnectionHandlerBase {
    setTargetDelta(delta: IPoint): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragNodeConnectionTargetHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragNodeConnectionTargetHandler>;
}

interface IParentConnectionEndpointHandler {
    handler: DragNodeConnectionHandlerBase;
    connector: FConnectorBase;
    baselineRect: IRoundedRect;
}
interface IParentConnectionHandlers {
    source: IParentConnectionEndpointHandler[];
    target: IParentConnectionEndpointHandler[];
}

declare class DragNodeItemHandler extends DragHandlerBase<unknown> {
    private readonly _injector;
    readonly nodeOrGroup: FNodeBase;
    children: DragNodeItemHandler[];
    sourceConnectionHandlers: DragNodeConnectionHandlerBase[];
    targetConnectionHandlers: DragNodeConnectionHandlerBase[];
    protected readonly type = "move-node";
    protected readonly kind = "drag-node";
    private readonly _startPosition;
    private readonly _startRect;
    private _applyConstraints;
    private _lastSoftResults;
    private _deltaConstraints;
    private _constraints;
    private _lastPosition;
    private _softParentConnectionHandlers;
    private readonly _mediator;
    constructor(_injector: Injector, nodeOrGroup: FNodeBase, children?: DragNodeItemHandler[], sourceConnectionHandlers?: DragNodeConnectionHandlerBase[], targetConnectionHandlers?: DragNodeConnectionHandlerBase[]);
    setConstraints(constraints: IDragNodeDeltaConstraints): void;
    setSoftParentConnectionHandlers(handlers: IParentConnectionHandlers[]): void;
    finalizeConstraints(): void;
    getLastRect(): IRect;
    prepareDragSequence(): void;
    onPointerMove(delta: IPoint): void;
    onPointerUp(): void;
    private _startPlus;
    private _redraw;
    private _applySoftExpansions;
    private _commitParentRect;
    private _updateParentConnectionHandlers;
    private _readConnectorRect;
    private _buildDelta;
    private _emitExpandedEvent;
    destroy(): void;
}

declare class FDragNodeStartEventData {
    readonly fNodeIds: string[];
    constructor(fNodeIds: string[]);
}

interface IMagneticAxisGuide {
    /** Guide coordinate (x or y) that we align to */
    guide?: number;
    /** Signed delta to apply to the dragged rect to align with the guide */
    delta?: number;
}

interface IMagneticGuidesResult {
    x: IMagneticAxisGuide;
    y: IMagneticAxisGuide;
}

declare function calculateMagneticGuides(elements: IRect[], target: IRect, alignThreshold?: number): IMagneticGuidesResult;

type MagneticLineRect = {
    left: number;
    top: number;
    width: number;
    height: number;
};
declare class MagneticLineElement {
    private readonly _element;
    constructor(browser: BrowserService, hostElement: HTMLElement, className?: string);
    show(): void;
    hide(): void;
    render(rect: Partial<MagneticLineRect>): void;
    clearRect(): void;
    destroy(): void;
}

declare class MagneticLineRenderer {
    private readonly _horizontal;
    private readonly _vertical;
    constructor(browser: BrowserService, hostElement: HTMLElement);
    drawVerticalLine(x: number, size: ISize, transform: ITransformModel): void;
    drawHorizontalLine(y: number, size: ISize, transform: ITransformModel): void;
    hideVertical(): void;
    hideHorizontal(): void;
    hideAll(): void;
    destroy(): void;
}

declare class MagneticLinesPreparationRequest {
    static readonly fToken: unique symbol;
}

declare class MagneticLinesPreparation implements IExecution<MagneticLinesPreparationRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _browser;
    private readonly _injector;
    private readonly _dragSession;
    private _renderer;
    handle(_: MagneticLinesPreparationRequest): void;
    private _draggedNodes;
    private _flowHostSize;
    private _createRenderer;
    private _notDraggedRects;
    static ɵfac: i0.ɵɵFactoryDeclaration<MagneticLinesPreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MagneticLinesPreparation>;
}

declare class MagneticLinesHandler {
    private _renderer;
    private _size;
    private _rects;
    private _timerId;
    private readonly _canvasTransform;
    private readonly _alignThreshold;
    constructor(injector: Injector, _renderer: MagneticLineRenderer, _size: ISize, _rects: IRect[]);
    scheduleRender(_draggedRect: IRect): void;
    private _renderGuides;
    private _renderVertical;
    private _renderHorizontal;
    _computeGuides(_draggedRect: IRect): IMagneticGuidesResult;
    clearGuides(): void;
}

interface IMagneticGapRect {
    left: number;
    top: number;
    width: number;
    height: number;
}

type MagneticRectsAxis = 'x' | 'y';
type MagneticRectsAlignMode = 'top' | 'center' | 'bottom' | 'left' | 'right';
interface IMagneticRectsResult {
    axis?: MagneticRectsAxis;
    delta?: number;
    gap?: number;
    rects: IMagneticGapRect[];
    alignMode?: MagneticRectsAlignMode;
    crossDelta?: number;
}

declare function calculateMagneticRects(elements: IRect[], target: IRect, alignThreshold?: number, spacingThreshold?: number): IMagneticRectsResult;

declare class MagneticRectElement {
    private readonly _element;
    private _isVisible;
    private _left;
    private _top;
    private _width;
    private _height;
    constructor(browser: BrowserService, hostElement: HTMLElement, className?: string);
    show(): void;
    hide(): void;
    render(left: number, top: number, width: number, height: number): void;
    clearRect(): void;
    destroy(): void;
}

declare class MagneticRectsRenderer {
    private readonly _browser;
    private readonly _hostElement;
    private readonly _className;
    private readonly _pool;
    private _activeCount;
    constructor(_browser: BrowserService, _hostElement: HTMLElement, _className?: string);
    draw(rects: IMagneticGapRect[], transform: ITransformModel): void;
    hideAll(): void;
    destroy(): void;
    private _getOrCreate;
}

declare class MagneticRectsPreparationRequest {
    static readonly fToken: unique symbol;
}

declare class MagneticRectsPreparation implements IExecution<MagneticRectsPreparationRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _browser;
    private readonly _injector;
    private readonly _dragSession;
    private _renderer;
    handle(_: MagneticRectsPreparationRequest): void;
    private _draggedNodes;
    private _getRenderer;
    private _notDraggedRects;
    static ɵfac: i0.ɵɵFactoryDeclaration<MagneticRectsPreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MagneticRectsPreparation>;
}

declare class MagneticRectsHandler {
    private readonly _renderer;
    private readonly _rects;
    private _timerId;
    private readonly _canvasTransform;
    private readonly _alignThreshold;
    private readonly _spacingThreshold;
    constructor(injector: Injector, _renderer: MagneticRectsRenderer, _rects: IRect[]);
    scheduleRender(_draggedRect: IRect): void;
    private _renderRects;
    _computeRects(_draggedRect: IRect): IMagneticRectsResult;
    clearGuides(): void;
}

declare class DragNodeHandler extends DragHandlerBase<FDragNodeStartEventData> {
    protected readonly type = "move-node";
    protected readonly kind = "drag-node";
    protected data(): FDragNodeStartEventData;
    private _magneticLines;
    private _magneticRects;
    /** Every dragged item (nodes + groups including deep children) */
    items: DragNodeItemHandler[];
    /** Roots of drag hierarchy (top-level items without selected parents) */
    roots: DragNodeItemHandler[];
    initialize(
    /** Every dragged item (nodes + groups including deep children) */
    items: DragNodeItemHandler[], 
    /** Roots of drag hierarchy (top-level items without selected parents) */
    roots: DragNodeItemHandler[]): void;
    setMagneticLines(handler: MagneticLinesHandler): void;
    setMagneticRects(handler: MagneticRectsHandler): void;
    calculateMagneticLinesGuides(delta: IPoint): IMagneticGuidesResult | undefined;
    calculateMagneticSnaps(delta: IPoint): {
        lines?: IMagneticGuidesResult;
        rects?: IMagneticRectsResult;
    };
    prepareDragSequence(): void;
    onPointerMove(delta: IPoint): void;
    onPointerUp(): void;
    private _previewRoots;
    private _rootsUnionRect;
    private _refreshDraggedNodes;
    destroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragNodeHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragNodeHandler>;
}

declare class DragNodeHierarchy {
    readonly rootHandlers: DragNodeItemHandler[];
    readonly participants: DragNodeItemHandler[];
    constructor(rootHandlers: DragNodeItemHandler[], participants: DragNodeItemHandler[]);
}

declare class CreateDragNodeHierarchy implements IExecution<CreateDragNodeHierarchyRequest, DragNodeHierarchy> {
    private readonly _injector;
    handle({ nodesAndGroups }: CreateDragNodeHierarchyRequest): DragNodeHierarchy;
    private _createHandlerByNodeId;
    private _linkParentsAndCollectRoots;
    static ɵfac: i0.ɵɵFactoryDeclaration<CreateDragNodeHierarchy, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CreateDragNodeHierarchy>;
}

declare class BuildDragNodeConstraintsRequest {
    readonly nodeOrGroup: FNodeBase;
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup: FNodeBase);
}

declare class BuildDragNodeConstraints implements IExecution<BuildDragNodeConstraintsRequest, IDragNodeDeltaConstraints> {
    private readonly _mediator;
    handle({ nodeOrGroup }: BuildDragNodeConstraintsRequest): IDragNodeDeltaConstraints;
    private _readCurrentRect;
    private _readParentsChain;
    private _buildConstraints;
    private _readParentBounds;
    private _calculateDifference;
    private _calculateMinimumDifference;
    private _calculateMaximumDifference;
    private _isAutoExpand;
    private _makeSoftLimit;
    static ɵfac: i0.ɵɵFactoryDeclaration<BuildDragNodeConstraints, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BuildDragNodeConstraints>;
}

declare class CreateDragNodeHandlerRequest {
    /** Root handlers (handlers without parents in the selection). */
    readonly rootHandlers: DragNodeItemHandler[];
    /** All handlers participating in the drag operation. */
    readonly participants: DragNodeItemHandler[];
    static readonly fToken: unique symbol;
    constructor(
    /** Root handlers (handlers without parents in the selection). */
    rootHandlers: DragNodeItemHandler[], 
    /** All handlers participating in the drag operation. */
    participants: DragNodeItemHandler[]);
}

declare class CreateDragNodeHandler implements IExecution<CreateDragNodeHandlerRequest, DragNodeHandler> {
    private readonly _dragInjector;
    private readonly _mediator;
    handle({ rootHandlers, participants }: CreateDragNodeHandlerRequest): DragNodeHandler;
    private _applyConstraintsToRoots;
    private _collectConnectionHandlers;
    private _attachSoftParentConnectionHandlers;
    private _calculateConstraints;
    static ɵfac: i0.ɵɵFactoryDeclaration<CreateDragNodeHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CreateDragNodeHandler>;
}

declare class ReadNodeBoundsWithPaddingsRequest {
    readonly nodeOrGroup: FNodeBase;
    readonly childrenPaddings: [number, number, number, number];
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup: FNodeBase, childrenPaddings: [number, number, number, number]);
}

declare class ReadNodeBoundsWithPaddingsResponse {
    readonly nodeOrGroup: FNodeBase;
    readonly boundingRect: IRect;
    readonly innerRect: IRect;
    readonly paddings: [number, number, number, number];
    constructor(nodeOrGroup: FNodeBase, boundingRect: IRect, innerRect: IRect, paddings: [number, number, number, number]);
}

declare class ReadNodeBoundsWithPaddings implements IExecution<ReadNodeBoundsWithPaddingsRequest, ReadNodeBoundsWithPaddingsResponse> {
    private readonly _mediator;
    handle({ nodeOrGroup, childrenPaddings, }: ReadNodeBoundsWithPaddingsRequest): ReadNodeBoundsWithPaddingsResponse;
    private _readBoundingRect;
    private _readOwnPaddings;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReadNodeBoundsWithPaddings, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ReadNodeBoundsWithPaddings>;
}

declare class AttachTargetConnectionDragHandlersToNodeRequest {
    /** Node move handler we attach connection handlers to. */
    readonly dragHandler: DragNodeItemHandler;
    /**
     * Connectors considered "source side" for connections (previously: outputIds).
     * These are source connector ids that are within current drag selection.
     */
    readonly sourceIds: string[];
    /**
     * Shared pool to reuse already created handlers for the same connection.
     */
    readonly handlerPool: DragNodeConnectionHandlerBase[];
    static readonly fToken: unique symbol;
    constructor(
    /** Node move handler we attach connection handlers to. */
    dragHandler: DragNodeItemHandler, 
    /**
     * Connectors considered "source side" for connections (previously: outputIds).
     * These are source connector ids that are within current drag selection.
     */
    sourceIds: string[], 
    /**
     * Shared pool to reuse already created handlers for the same connection.
     */
    handlerPool: DragNodeConnectionHandlerBase[]);
}

declare class AttachTargetConnectionDragHandlersToNode implements IExecution<AttachTargetConnectionDragHandlersToNodeRequest, void> {
    private readonly _store;
    private readonly _dragInjector;
    private get _connections();
    handle(request: AttachTargetConnectionDragHandlersToNodeRequest): void;
    private _getInputConnections;
    private _getNodeInputIds;
    private _createAndSetConnectionToNodeHandler;
    private _getExistingConnectionHandler;
    private _createConnectionHandler;
    static ɵfac: i0.ɵɵFactoryDeclaration<AttachTargetConnectionDragHandlersToNode, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AttachTargetConnectionDragHandlersToNode>;
}

declare class AttachSourceConnectionDragHandlersToNodeRequest {
    /** Node move handler we attach connection handlers to. */
    readonly dragHandler: DragNodeItemHandler;
    /**
     * Connectors considered "target side" for connections (previously: inputIds).
     * These are target connector ids that are within current drag selection.
     */
    readonly targetIds: string[];
    /**
     * Shared pool to reuse already created handlers for the same connection.
     */
    readonly handlerPool: DragNodeConnectionHandlerBase[];
    static readonly fToken: unique symbol;
    constructor(
    /** Node move handler we attach connection handlers to. */
    dragHandler: DragNodeItemHandler, 
    /**
     * Connectors considered "target side" for connections (previously: inputIds).
     * These are target connector ids that are within current drag selection.
     */
    targetIds: string[], 
    /**
     * Shared pool to reuse already created handlers for the same connection.
     */
    handlerPool: DragNodeConnectionHandlerBase[]);
}

declare class AttachSourceConnectionDragHandlersToNode implements IExecution<AttachSourceConnectionDragHandlersToNodeRequest, void> {
    private readonly _store;
    private readonly _dragInjector;
    private get _connections();
    handle(request: AttachSourceConnectionDragHandlersToNodeRequest): void;
    _getOutputConnections(nodeOrGroup: FNodeBase): FConnectionBase[];
    private _getNodeOutputIds;
    private _createAndSetConnectionToNodeHandler;
    private _getExistingConnectionHandler;
    private _createConnectionHandler;
    static ɵfac: i0.ɵɵFactoryDeclaration<AttachSourceConnectionDragHandlersToNode, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AttachSourceConnectionDragHandlersToNode>;
}

declare class AttachSoftParentConnectionDragHandlersToNodeRequest {
    /** Node move handler that owns soft parent constraints. */
    readonly dragHandler: DragNodeItemHandler;
    /** Constraints calculated for the root handler. */
    readonly constraints: IDragNodeDeltaConstraints;
    /** Shared pool to reuse already created handlers for the same connection. */
    readonly handlerPool: DragNodeConnectionHandlerBase[];
    static readonly fToken: unique symbol;
    constructor(
    /** Node move handler that owns soft parent constraints. */
    dragHandler: DragNodeItemHandler, 
    /** Constraints calculated for the root handler. */
    constraints: IDragNodeDeltaConstraints, 
    /** Shared pool to reuse already created handlers for the same connection. */
    handlerPool: DragNodeConnectionHandlerBase[]);
}

declare class AttachSoftParentConnectionDragHandlersToNode implements IExecution<AttachSoftParentConnectionDragHandlersToNodeRequest, void> {
    private readonly _store;
    private readonly _mediator;
    private readonly _dragInjector;
    handle({ dragHandler, constraints, handlerPool, }: AttachSoftParentConnectionDragHandlersToNodeRequest): void;
    private _buildParentConnectionHandlers;
    private _getExistingConnectionHandler;
    private _createConnectionHandler;
    private _readConnectorRect;
    static ɵfac: i0.ɵɵFactoryDeclaration<AttachSoftParentConnectionDragHandlersToNode, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AttachSoftParentConnectionDragHandlersToNode>;
}

declare class AttachDragNodeHandlerFromSelectionRequest {
    readonly nodeOrGroup?: FNodeBase | undefined;
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup?: FNodeBase | undefined);
}

declare class AttachDragNodeHandlerFromSelection implements IExecution<AttachDragNodeHandlerFromSelectionRequest, DragNodeHandler> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragSession;
    handle({ nodeOrGroup }: AttachDragNodeHandlerFromSelectionRequest): DragNodeHandler;
    private _collectSelected;
    private _findNodeByHost;
    private _withDeepChildren;
    private _collectSourceConnectorIds;
    private _collectTargetConnectorIds;
    private _attachConnectionHandlers;
    static ɵfac: i0.ɵɵFactoryDeclaration<AttachDragNodeHandlerFromSelection, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AttachDragNodeHandlerFromSelection>;
}

declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof CreateDragNodeHierarchy | typeof ReadNodeBoundsWithPaddings | typeof BuildDragNodeConstraints | typeof AttachSoftParentConnectionDragHandlersToNode | typeof CreateDragNodeHandler | typeof AttachTargetConnectionDragHandlersToNode | typeof AttachSourceConnectionDragHandlersToNode | typeof AttachDragNodeHandlerFromSelection)[];

declare class DragNodeFinalizeRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class DragNodeFinalize implements IExecution<DragNodeFinalizeRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragSession;
    private _dragHandler?;
    handle({ event }: DragNodeFinalizeRequest): void;
    private _getDragHandler;
    private _buildDragDelta;
    private _applySnapToDelta;
    private _hasLineSnapValue;
    private _hasRectSnapValue;
    private _finalizeMove;
    private _buildMoveNodesEvent;
    private _emitNodeIntersectIfNeeded;
    private _isDraggedJustOneNode;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragNodeFinalize, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragNodeFinalize>;
}

declare class DragNodePreparationRequest {
    readonly event: IPointerEvent;
    readonly trigger: FEventTrigger;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent, trigger: FEventTrigger);
}

declare class DragNodePreparation implements IExecution<DragNodePreparationRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragSession;
    handle({ event, trigger }: DragNodePreparationRequest): void;
    private _canStartDrag;
    private _isDragHandle;
    private _findDraggableNode;
    private _storePointerDownContext;
    private _buildDragNodeHandler;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragNodePreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DragNodePreparation>;
}

type FMoveNodePosition = {
    id: string;
    position: IPoint;
};
/**
 * Event that is emitted when nodes and groups are moved.
 * It contains the moved nodes and groups and their new positions.
 */
declare class FMoveNodesEvent {
    /** Preferred name */
    readonly nodes: FMoveNodePosition[];
    /** @deprecated Use `nodes` */
    readonly fNodes: FMoveNodePosition[];
    constructor(nodes: FMoveNodePosition[]);
}

declare const DRAG_NODE_HANDLER_TYPE = "move-node";
declare const DRAG_NODE_HANDLER_KIND = "drag-node";
declare function isDragNodeHandler(value: DragHandlerBase<unknown>): value is DragNodeHandler;

declare const NODE_PROVIDERS: (typeof MagneticLinesPreparation | typeof MagneticRectsPreparation | typeof _foblex_flow.CreateDragNodeHierarchy | typeof _foblex_flow.ReadNodeBoundsWithPaddings | typeof _foblex_flow.BuildDragNodeConstraints | typeof _foblex_flow.AttachSoftParentConnectionDragHandlersToNode | typeof _foblex_flow.CreateDragNodeHandler | typeof _foblex_flow.AttachTargetConnectionDragHandlersToNode | typeof _foblex_flow.AttachSourceConnectionDragHandlersToNode | typeof _foblex_flow.AttachDragNodeHandlerFromSelection | typeof DragNodeFinalize | typeof DragNodePreparation)[];

declare class ApplyChildResizeConstraintsRequest {
    readonly rect: IRect;
    readonly childrenBounds: IRect | null;
    static readonly fToken: unique symbol;
    constructor(rect: IRect, childrenBounds: IRect | null);
}

declare class ApplyChildResizeConstraints implements IExecution<ApplyChildResizeConstraintsRequest, void> {
    handle({ rect, childrenBounds }: ApplyChildResizeConstraintsRequest): void;
    private _apply;
    private _restrictLeft;
    private _restrictTop;
    private _restrictRight;
    private _restrictBottom;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplyChildResizeConstraints, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApplyChildResizeConstraints>;
}

interface IResizeLimit {
    boundingRect: IRect;
    innerRect: IRect;
    nodeOrGroup: FNodeBase;
}

interface IResizeLimits {
    softLimits: IResizeLimit[];
    hardLimit: IResizeLimit | undefined;
}

interface IResizeConstraint {
    limits: IResizeLimits;
    childrenBounds: IRect | null;
    minimumSize: ISize;
}

interface IResizeOverflow {
    left: number;
    right: number;
    top: number;
    bottom: number;
}

declare const RESIZE_DIRECTIONS: {
    left: {
        x: number;
        y: number;
    };
    "left-top": {
        x: number;
        y: number;
    };
    top: {
        x: number;
        y: number;
    };
    "right-top": {
        x: number;
        y: number;
    };
    right: {
        x: number;
        y: number;
    };
    "right-bottom": {
        x: number;
        y: number;
    };
    bottom: {
        x: number;
        y: number;
    };
    "left-bottom": {
        x: number;
        y: number;
    };
};

declare class ApplyParentResizeConstraintsRequest {
    rect: IRect;
    limits: IResizeLimits;
    static readonly fToken: unique symbol;
    constructor(rect: IRect, limits: IResizeLimits);
}

/**
 * Resize constraints behavior:
 * - SOFT (parents): if the child hits the innerRect, a NEW parent rect is calculated
 *   from the original boundingRect and applied via updatePosition/Size/redraw.
 *   The original boundingRect/innerRect are never mutated.
 * - HARD (child): the child rect is clamped to stay within the hard.innerRect.
 */
declare class ApplyParentResizeConstraints implements IExecution<ApplyParentResizeConstraintsRequest, void> {
    private readonly _mediator;
    /** Entry point: applies soft and hard resize constraints. */
    handle({ rect, limits }: ApplyParentResizeConstraintsRequest): void;
    private _applyResizeConstraints;
    /** Returns a copy of the child rect pre-clamped to the hard innerRect if it exists. */
    private _clampedCopyForCalculation;
    /** Clamps the rect inside the given innerRect. Mutates the rect directly. */
    private _clampRectToInner;
    /** Iterates over all soft limits and applies expansion if overflow is detected. */
    private _applySoftParentExpansions;
    /**
     * If the child overflows the parent's innerRect, calculate a new parent rect
     * based on the original boundingRect and apply it. Otherwise, reset to original.
     */
    private _expandParentFromOriginalIfOverflow;
    /** Returns true if any overflow exists. */
    private _hasOverflow;
    /** Computes overflow values for each side relative to innerRect. */
    private _computeOverflow;
    /** Builds new parent rect from original rect and overflow values. */
    private _buildExpandedParentRect;
    /** Applies the calculated parent rect to the node/group. */
    private _applyParentRect;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplyParentResizeConstraints, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApplyParentResizeConstraints>;
}

declare class CalculateChangedRectFromDifferenceRequest {
    readonly originalRect: IRect;
    readonly difference: IPoint;
    readonly handleType: EFResizeHandleType;
    readonly minimumSize: ISize;
    static readonly fToken: unique symbol;
    constructor(originalRect: IRect, difference: IPoint, handleType: EFResizeHandleType, minimumSize: ISize);
}

declare class CalculateChangedRectFromDifference implements IExecution<CalculateChangedRectFromDifferenceRequest, IRect> {
    handle({ originalRect, difference, handleType, minimumSize, }: CalculateChangedRectFromDifferenceRequest): IRect;
    private _changeSizeInRect;
    private _changePosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateChangedRectFromDifference, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateChangedRectFromDifference>;
}

declare class CalculateDirectChildrenUnionRectRequest {
    nodeOrGroup: FNodeBase;
    paddings: [number, number, number, number];
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup: FNodeBase, paddings: [number, number, number, number]);
}

declare class CalculateDirectChildrenUnionRect implements IExecution<CalculateDirectChildrenUnionRectRequest, IRect | null> {
    private readonly _mediator;
    private readonly _store;
    private get _allNodesAndGroups();
    handle({ nodeOrGroup, paddings }: CalculateDirectChildrenUnionRectRequest): IRect | null;
    private _calculateDirectChildren;
    private _normalizeRect;
    private _concatRectWithParentPadding;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateDirectChildrenUnionRect, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateDirectChildrenUnionRect>;
}

declare class CalculateResizeLimitsRequest {
    readonly nodeOrGroup: FNodeBase;
    readonly rect: IRect;
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup: FNodeBase, rect: IRect);
}

declare class CalculateResizeLimits implements IExecution<CalculateResizeLimitsRequest, IResizeConstraint> {
    private readonly _mediator;
    handle({ nodeOrGroup, rect }: CalculateResizeLimitsRequest): IResizeConstraint;
    private _calculateNodePaddings;
    private _getNormalizedChildrenBounds;
    private _getParentsChain;
    private _buildSoftHardLimits;
    private _getParentInfo;
    private _isAutoExpand;
    private _makeLimit;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateResizeLimits, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateResizeLimits>;
}

declare class ResizeNodeFinalizeRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class ResizeNodeFinalize implements IExecution<ResizeNodeFinalizeRequest, void> {
    private readonly _dragSession;
    handle(_request: ResizeNodeFinalizeRequest): void;
    private _isNodeResizeHandler;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodeFinalize, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodeFinalize>;
}

declare class FResizeNodeStartEventData {
    readonly fNodeId: string;
    constructor(fNodeId: string);
}

declare class ResizeNodeConnectionHandlerBase {
    private readonly _mediator;
    private readonly _store;
    private readonly _behaviour;
    private _source;
    private _target;
    private _sourceRef;
    private _targetRef;
    private _sourceRect;
    private _targetRect;
    connection: FConnectionBase;
    initialize(connection: FConnectionBase): void;
    setSourceRect(rect: IRoundedRect): void;
    setTargetRect(rect: IRoundedRect): void;
    protected redraw(): void;
    private _buildLine;
    private _readRectRef;
    private _resolveRotationContext;
}

declare class ResizeNodeConnectionBothSidesHandler extends ResizeNodeConnectionHandlerBase {
    private _sourceUpdated;
    private _targetUpdated;
    setSourceRect(rect: IRoundedRect): void;
    setTargetRect(rect: IRoundedRect): void;
    private _redrawIfReady;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodeConnectionBothSidesHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodeConnectionBothSidesHandler>;
}

declare class ResizeNodeConnectionSourceHandler extends ResizeNodeConnectionHandlerBase {
    setSourceRect(rect: IRoundedRect): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodeConnectionSourceHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodeConnectionSourceHandler>;
}

declare class ResizeNodeConnectionTargetHandler extends ResizeNodeConnectionHandlerBase {
    setTargetRect(rect: IRoundedRect): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodeConnectionTargetHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodeConnectionTargetHandler>;
}

interface IResizeNodeConnectionEndpointHandler {
    handler: ResizeNodeConnectionHandlerBase;
    connector: FConnectorBase;
}
interface IResizeNodeConnectionHandlers {
    source: IResizeNodeConnectionEndpointHandler[];
    target: IResizeNodeConnectionEndpointHandler[];
}

declare class ResizeNodeHandler extends DragHandlerBase<FResizeNodeStartEventData> {
    protected readonly type = "node-resize";
    protected readonly kind = "resize-node";
    protected data(): FResizeNodeStartEventData;
    private readonly _mediator;
    private readonly _reflowOrchestrator;
    private _baselineRect;
    private _constraints;
    private _lastRect;
    private _nodeOrGroup;
    private _handleType;
    private _nodeConnections;
    private _softParentConnections;
    initialize(nodeOrGroup: FNodeBase, handleType: EFResizeHandleType): void;
    setNodeConnectionHandlers(handlers: IResizeNodeConnectionHandlers): void;
    setSoftParentConnectionHandlers(handlers: IResizeNodeConnectionHandlers[]): void;
    prepareDragSequence(): void;
    onPointerMove(delta: IPoint): void;
    onPointerUp(): void;
    private _readBaselineRect;
    private _buildConstraints;
    private _calcNextRect;
    private _applyConstraints;
    private _commitRect;
    private _fallbackRectFromModel;
    private _applyConnectionHandlers;
    private _readConnectorRect;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodeHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodeHandler>;
}

declare class ResizeNodePreparationRequest {
    readonly event: IPointerEvent;
    readonly fTrigger: FEventTrigger;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
}

declare class ResizeNodePreparation implements IExecution<ResizeNodePreparationRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragSession;
    private readonly _dragInjector;
    private get _transform();
    handle({ event, fTrigger }: ResizeNodePreparationRequest): void;
    private _isResizeHandle;
    private _findResizableNode;
    private _selectBeforeResize;
    private _readResizeHandleType;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodePreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodePreparation>;
}

declare class AttachResizeConnectionDragHandlersToNodeRequest {
    readonly handler: ResizeNodeHandler;
    readonly nodeOrGroup: FNodeBase;
    static readonly fToken: unique symbol;
    constructor(handler: ResizeNodeHandler, nodeOrGroup: FNodeBase);
}

declare class AttachResizeConnectionDragHandlersToNode implements IExecution<AttachResizeConnectionDragHandlersToNodeRequest, void> {
    private readonly _store;
    private readonly _mediator;
    private readonly _dragInjector;
    handle({ handler, nodeOrGroup }: AttachResizeConnectionDragHandlersToNodeRequest): void;
    private _readSoftParents;
    private _collectSourceConnectorIds;
    private _collectTargetConnectorIds;
    private _buildConnectionHandlersForNode;
    private _createConnectionHandler;
    static ɵfac: i0.ɵɵFactoryDeclaration<AttachResizeConnectionDragHandlersToNode, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AttachResizeConnectionDragHandlersToNode>;
}

declare const RESIZE_NODE_HANDLER_TYPE = "node-resize";
declare const RESIZE_NODE_HANDLER_KIND = "resize-node";
declare function isResizeNodeHandler(value: DragHandlerBase<unknown>): value is ResizeNodeHandler;

declare const NODE_RESIZE_PROVIDERS: (typeof ApplyChildResizeConstraints | typeof ApplyParentResizeConstraints | typeof CalculateChangedRectFromDifference | typeof CalculateDirectChildrenUnionRect | typeof CalculateResizeLimits | typeof ResizeNodeFinalize | typeof AttachResizeConnectionDragHandlersToNode | typeof ResizeNodePreparation)[];

declare class RotateNodeFinalizeRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class RotateNodeFinalize implements IExecution<RotateNodeFinalizeRequest, void> {
    private readonly _dragSession;
    handle(_request: RotateNodeFinalizeRequest): void;
    private _isValid;
    static ɵfac: i0.ɵɵFactoryDeclaration<RotateNodeFinalize, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RotateNodeFinalize>;
}

declare class RotateNodePreparationRequest {
    readonly event: IPointerEvent;
    readonly fTrigger: FEventTrigger;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
}

declare class RotateNodePreparation implements IExecution<RotateNodePreparationRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragContext;
    private readonly _dragInjector;
    private get _transform();
    handle(request: RotateNodePreparationRequest): void;
    private _isPreparationAllowed;
    private _findRotatableNode;
    private _selectBeforeRotate;
    private _buildInputConnectionHandlers;
    private _buildOutputConnectionHandlers;
    static ɵfac: i0.ɵɵFactoryDeclaration<RotateNodePreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RotateNodePreparation>;
}

declare class FRotateNodeStartEventData {
    readonly fNodeId: string;
    constructor(fNodeId: string);
}

type TRotateConnectionHandler = {
    connection: DragNodeConnectionHandlerBase;
    connector: IPoint;
};
declare class RotateNodeHandler extends DragHandlerBase<FRotateNodeStartEventData> {
    protected readonly type = "node-rotate";
    protected readonly kind = "rotate-node";
    protected data(): FRotateNodeStartEventData;
    private readonly _store;
    private readonly _mediator;
    private readonly _dragSession;
    private _nodeOrGroup;
    private _sourceConnections;
    private _targetConnections;
    private _startRotation;
    private _nodeRect;
    private _nodeCenter;
    private _pointerDownInFlow;
    /**
     * Difference between pointer angle and node rotation at pointer-down.
     * This lets us keep rotation “locked” to the initial grab angle.
     */
    private _rotationOffsetDeg;
    private get _transform();
    initialize(nodeOrGroup: FNodeBase, sourceConnections: TRotateConnectionHandler[], targetConnections: TRotateConnectionHandler[]): void;
    prepareDragSequence(): void;
    onPointerMove(delta: IPoint): void;
    onPointerUp(): void;
    private _readNodeRect;
    private _calculatePointerDownInFlow;
    private _angleDeg;
    private _applyRotation;
    private _deltaAfterRotation;
    static ɵfac: i0.ɵɵFactoryDeclaration<RotateNodeHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RotateNodeHandler>;
}

declare function calculateDifferenceAfterRotation(position: {
    x: number;
    y: number;
}, rotation: number, pivot: {
    x: number;
    y: number;
}): {
    x: number;
    y: number;
};
declare function calculatePositionAfterRotation(position: {
    x: number;
    y: number;
}, rotation: number, pivot: {
    x: number;
    y: number;
}): {
    x: number;
    y: number;
};

declare const ROTATE_NODE_HANDLER_TYPE = "node-rotate";
declare const ROTATE_NODE_HANDLER_KIND = "rotate-node";
declare function isRotateNodeHandler(value: DragHandlerBase<unknown>): value is RotateNodeHandler;

declare const NODE_ROTATE_PROVIDERS: (typeof RotateNodeFinalize | typeof RotateNodePreparation)[];

declare class PinchToZoomFinalizeRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class PinchToZoomFinalize implements IExecution<PinchToZoomFinalizeRequest, void> {
    private readonly _dragSession;
    handle(_: PinchToZoomFinalizeRequest): void;
    private _hasPinchZoomHandler;
    static ɵfac: i0.ɵɵFactoryDeclaration<PinchToZoomFinalize, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PinchToZoomFinalize>;
}

declare class PinchToZoomHandler extends DragHandlerBase<unknown> {
    protected readonly type = "pinch-to-zoom";
    protected readonly kind = "pinch-to-zoom";
    private readonly _store;
    private get _flowHost();
    private get _canvas();
    private get _zoomComponent();
    private _startDistance;
    private _startScale;
    private _touches;
    initialize(touches: TouchList): void;
    prepareDragSequence(): void;
    onPointerMove(_: IPoint, event: IPointerEvent): void;
    private _clamp;
    private _castPositionToFlow;
    private _reset;
    onPointerUp(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PinchToZoomHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PinchToZoomHandler>;
}

declare class PinchToZoomPreparationRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class PinchToZoomPreparation implements IExecution<PinchToZoomPreparationRequest, void> {
    private readonly _dragInjector;
    private readonly _store;
    private readonly _dragSession;
    handle({ event }: PinchToZoomPreparationRequest): void;
    private _canStart;
    private _hasZoomComponent;
    private _getHandler;
    static ɵfac: i0.ɵɵFactoryDeclaration<PinchToZoomPreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PinchToZoomPreparation>;
}

declare const PINCH_TO_ZOOM_PROVIDERS: (typeof PinchToZoomFinalize | typeof PinchToZoomPreparation)[];

declare class SelectByPointerRequest {
    readonly event: IPointerEvent;
    readonly trigger: FEventTrigger;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent, trigger: FEventTrigger);
}

/**
 * Implements the functionality for selecting elements in a graphical interface.
 * This class handles both single and multi-selection, updating the selection state
 * of elements and managing related data.
 *
 * Logic flow:
 * 1. **Validate the selection event**:
 *    - The event is considered valid if it occurs within the flow boundaries
 *      and there are no active draggable data operations.
 *
 * 2. **Determine the target element to select**:
 *    - The target element is determined based on the event’s target.
 *      It can be a node, a group of nodes, or a connection.
 *    - If no element is found, the current selection state is cleared.
 *
 * 3. **Update element layers**:
 *    - If an element is found, its visual layer and the layers of its child elements are updated.
 *
 * 4. **Single or multi-selection**:
 *    - If the event meets the criteria for multi-selection (e.g., a modifier key is pressed),
 *      multi-selection logic is applied.
 *    - Otherwise, single-selection logic is used.
 *
 * 5. **Single-selection logic**:
 *    - If the element is not selected and can be selected:
 *      - Clear the selection of all other elements.
 *      - Mark the current element as selected.
 *    - If the element cannot be selected, the current selection is cleared.
 *
 * 6. **Multi-selection logic**:
 *    - If the element is already selected, it is removed from the selection.
 *    - If the element is not selected and can be selected, it is added to the selection.
 *
 * 7. **Manage selection state**:
 *    - Adding or removing an element from the selection triggers the corresponding methods.
 *    - Selection state is tracked in the shared context for future use.
 */
declare class SelectByPointer implements IExecution<SelectByPointerRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragSession;
    handle({ event, trigger }: SelectByPointerRequest): void;
    private _isSelectionAllowed;
    private _resolveSelectable;
    private _findNodeOrGroupAt;
    private _findConnectionAt;
    private _deferRaiseLayerFor;
    private _applySingleSelect;
    private _applyToggleSelect;
    private _clearSelection;
    private _select;
    private _deselect;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectByPointer, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SelectByPointer>;
}

declare const DRAG_SELECT_BY_POINTER_PROVIDERS: (typeof SelectByPointer)[];

declare class SelectionAreaFinalizeRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class SelectionAreaFinalize implements IExecution<SelectionAreaFinalizeRequest, void> {
    private readonly _dragSession;
    handle(_request: SelectionAreaFinalizeRequest): void;
    private _isValid;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionAreaFinalize, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SelectionAreaFinalize>;
}

declare class SelectionAreaHandler extends DragHandlerBase<unknown> {
    protected readonly type = "selection-area";
    protected readonly kind = "selection-area";
    private readonly _store;
    private readonly _dragSession;
    private readonly _mediator;
    private _canBeSelected;
    private _selectedByMove;
    private get _transform();
    private get _canvasPosition();
    private get _instance();
    prepareDragSequence(): void;
    onPointerMove(difference: IPoint): void;
    private _getMinimumPoint;
    onPointerUp(): void;
    private _draw;
    private _show;
    private _hide;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionAreaHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SelectionAreaHandler>;
}

declare class SelectionAreaPreparationRequest {
    readonly event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

declare class SelectionAreaPreparation implements IExecution<SelectionAreaPreparationRequest, void> {
    private readonly _store;
    private readonly _dragSession;
    private readonly _dragInjector;
    private get _instance();
    handle(request: SelectionAreaPreparationRequest): void;
    private _isValid;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionAreaPreparation, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SelectionAreaPreparation>;
}

declare const DRAG_SELECTION_AREA_PROVIDERS: (typeof SelectionAreaFinalize | typeof SelectionAreaPreparation)[];

declare class FDragBlockerDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<FDragBlockerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FDragBlockerDirective, "[fDragBlocker]", never, {}, {}, never, never, false, never>;
}

declare class FSelectionChangeEvent implements ICurrentSelection {
    readonly nodeIds: string[];
    readonly groupIds: string[];
    readonly connectionIds: string[];
    /** @deprecated Use `nodeIds` */
    get fNodeIds(): string[];
    /** @deprecated Use `groupIds` */
    get fGroupIds(): string[];
    /** @deprecated Use `connectionIds` */
    get fConnectionIds(): string[];
    constructor(nodeIds: string[], groupIds: string[], connectionIds: string[]);
}

declare abstract class FDraggableBase extends DragAndDropBase {
    readonly hostElement: any;
    abstract fSelectionChange: EventEmitter<FSelectionChangeEvent>;
    /** @deprecated Use `fNodeConnectionsIntersection` */
    abstract fNodeIntersectedWithConnections: EventEmitter<FNodeIntersectedWithConnections>;
    abstract fNodeConnectionsIntersection: OutputEmitterRef<FNodeConnectionsIntersectionEvent>;
    abstract fEmitOnNodeIntersect: boolean;
    abstract fCreateNode: EventEmitter<FCreateNodeEvent>;
    abstract fMoveNodes: EventEmitter<FMoveNodesEvent>;
    abstract fReassignConnection: EventEmitter<FReassignConnectionEvent>;
    abstract fCreateConnection: EventEmitter<FCreateConnectionEvent>;
    abstract fConnectionWaypointsChanged: OutputEmitterRef<FConnectionWaypointsChangedEvent>;
    abstract fDropToGroup: EventEmitter<FDropToGroupEvent>;
    abstract vCellSize: InputSignalWithTransform<number, unknown>;
    abstract hCellSize: InputSignalWithTransform<number, unknown>;
    abstract fCellSizeWhileDragging: InputSignalWithTransform<boolean, unknown>;
    abstract fDragStarted: EventEmitter<FDragStartedEvent>;
    abstract fDragEnded: EventEmitter<void>;
}

declare class FDraggableDirective extends FDraggableBase implements OnInit, AfterViewInit, OnDestroy {
    private readonly _result;
    private readonly _mediator;
    private readonly _platform;
    disabled: boolean;
    fMultiSelectTrigger: FEventTrigger;
    fReassignConnectionTrigger: FEventTrigger;
    fCreateConnectionTrigger: FEventTrigger;
    fConnectionWaypointsTrigger: i0.InputSignal<FEventTrigger>;
    fMoveControlPointTrigger: FEventTrigger;
    fNodeResizeTrigger: FEventTrigger;
    fNodeRotateTrigger: FEventTrigger;
    fNodeMoveTrigger: FEventTrigger;
    fCanvasMoveTrigger: FEventTrigger;
    fExternalItemTrigger: FEventTrigger;
    fSelectionChange: EventEmitter<FSelectionChangeEvent>;
    /** @deprecated Use `fNodeConnectionsIntersection` */
    fNodeIntersectedWithConnections: EventEmitter<FNodeIntersectedWithConnections>;
    readonly fNodeConnectionsIntersection: i0.OutputEmitterRef<FNodeConnectionsIntersectionEvent>;
    fEmitOnNodeIntersect: boolean;
    fCreateNode: EventEmitter<FCreateNodeEvent<any>>;
    fMoveNodes: EventEmitter<FMoveNodesEvent>;
    fReassignConnection: EventEmitter<FReassignConnectionEvent>;
    fCreateConnection: EventEmitter<FCreateConnectionEvent>;
    fConnectionWaypointsChanged: i0.OutputEmitterRef<FConnectionWaypointsChangedEvent>;
    fDropToGroup: EventEmitter<FDropToGroupEvent>;
    /**
     * Defines the vertical cell size for the grid.
     * This value is used to snap nodes to a vertical grid while dragging.
     * The default value is `1`, which means that nodes will snap to every pixel vertically.
     */
    vCellSize: i0.InputSignalWithTransform<number, unknown>;
    /**
     * Defines the horizontal cell size for the grid.
     * This value is used to snap nodes to a horizontal grid while dragging.
     * The default value is `1`, which means that nodes will snap to every pixel horizontally.
     */
    hCellSize: i0.InputSignalWithTransform<number, unknown>;
    /**
     * Defines whether the cell size should be applied while dragging.
     * If set to `true`, the dragged nodes will snap to the grid defined by `vCellSize` and `hCellSize`.
     * If set to `false`, the nodes will move freely without snapping to the grid.
     */
    fCellSizeWhileDragging: i0.InputSignalWithTransform<boolean, unknown>;
    fDragStarted: EventEmitter<FDragStartedEvent<unknown>>;
    fDragEnded: EventEmitter<void>;
    private readonly _dragHandlerInjector;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    onPointerDown(event: IPointerEvent): boolean;
    protected prepareDragSequence(event: IPointerEvent): void;
    protected onSelect(event: Event): void;
    onPointerMove(event: IPointerEvent): void;
    onPointerUp(event: IPointerEvent): void;
    protected finalizeDragSequence(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableDirective, "f-flow[fDraggable]", ["fDraggable"], { "disabled": { "alias": "fDraggableDisabled"; "required": false; }; "fMultiSelectTrigger": { "alias": "fMultiSelectTrigger"; "required": false; }; "fReassignConnectionTrigger": { "alias": "fReassignConnectionTrigger"; "required": false; }; "fCreateConnectionTrigger": { "alias": "fCreateConnectionTrigger"; "required": false; }; "fConnectionWaypointsTrigger": { "alias": "fConnectionWaypointsTrigger"; "required": false; "isSignal": true; }; "fMoveControlPointTrigger": { "alias": "fMoveControlPointTrigger"; "required": false; }; "fNodeResizeTrigger": { "alias": "fNodeResizeTrigger"; "required": false; }; "fNodeRotateTrigger": { "alias": "fNodeRotateTrigger"; "required": false; }; "fNodeMoveTrigger": { "alias": "fNodeMoveTrigger"; "required": false; }; "fCanvasMoveTrigger": { "alias": "fCanvasMoveTrigger"; "required": false; }; "fExternalItemTrigger": { "alias": "fExternalItemTrigger"; "required": false; }; "fEmitOnNodeIntersect": { "alias": "fEmitOnNodeIntersect"; "required": false; }; "vCellSize": { "alias": "vCellSize"; "required": false; "isSignal": true; }; "hCellSize": { "alias": "hCellSize"; "required": false; "isSignal": true; }; "fCellSizeWhileDragging": { "alias": "fCellSizeWhileDragging"; "required": false; "isSignal": true; }; }, { "fSelectionChange": "fSelectionChange"; "fNodeIntersectedWithConnections": "fNodeIntersectedWithConnections"; "fNodeConnectionsIntersection": "fNodeConnectionsIntersection"; "fCreateNode": "fCreateNode"; "fMoveNodes": "fMoveNodes"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; "fConnectionWaypointsChanged": "fConnectionWaypointsChanged"; "fDropToGroup": "fDropToGroup"; "fDragStarted": "fDragStarted"; "fDragEnded": "fDragEnded"; }, never, never, false, never>;
    static ngAcceptInputType_disabled: unknown;
    static ngAcceptInputType_fEmitOnNodeIntersect: unknown;
}

declare class FDraggableDataContext {
    selectedItems: ISelectable[];
    isSelectedChanged: boolean;
    onPointerDownScale: number;
    onPointerDownPosition: Point;
    draggableItems: DragHandlerBase<unknown>[];
    autoPanFrameId: number | null;
    lastPointerPosition: IPoint | null;
    isAutoPanCanvasMoved: boolean;
    reset(): void;
    markSelectionAsChanged(): void;
    rememberPointerPosition(event: IPointerEvent): void;
    isEmpty(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDataContext, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FDraggableDataContext>;
}

declare function isDragBlocker(element: HTMLElement): boolean;

declare const F_DRAGGABLE_PROVIDERS: (typeof _foblex_flow.EmitEndDragSequenceEvent | typeof _foblex_flow.EmitStartDragSequenceEvent | typeof _foblex_flow.DragCanvasFinalize | typeof _foblex_flow.DragCanvasPreparation | typeof _foblex_flow.ResolveConnectableOutputForOutlet | typeof _foblex_flow.CreateConnectionFinalize | typeof _foblex_flow.CreateConnectionCreateDragHandler | typeof _foblex_flow.CreateConnectionFromOutletPreparation | typeof _foblex_flow.CreateConnectionFromOutputPreparation | typeof _foblex_flow.CreateConnectionPreparation | typeof _foblex_flow.MagneticLinesPreparation | typeof _foblex_flow.MagneticRectsPreparation | typeof _foblex_flow.CreateDragNodeHierarchy | typeof _foblex_flow.ReadNodeBoundsWithPaddings | typeof _foblex_flow.BuildDragNodeConstraints | typeof _foblex_flow.AttachSoftParentConnectionDragHandlersToNode | typeof _foblex_flow.CreateDragNodeHandler | typeof _foblex_flow.AttachTargetConnectionDragHandlersToNode | typeof _foblex_flow.AttachSourceConnectionDragHandlersToNode | typeof _foblex_flow.AttachDragNodeHandlerFromSelection | typeof _foblex_flow.DragNodeFinalize | typeof _foblex_flow.DragNodePreparation | typeof _foblex_flow.DropToGroupFinalize | typeof _foblex_flow.SortDropCandidatesByLayer | typeof _foblex_flow.DragExternalItemCreatePlaceholder | typeof _foblex_flow.DragExternalItemCreatePreview | typeof _foblex_flow.DragExternalItemFinalize | typeof _foblex_flow.DragExternalItemPreparation | typeof _foblex_flow.PreventDefaultIsExternalItem | typeof _foblex_flow.DropToGroupPreparation | typeof _foblex_flow.ReassignConnectionFinalize | typeof _foblex_flow.ReassignConnectionPreparation | typeof _foblex_flow.DragConnectionWaypointFinalize | typeof _foblex_flow.DragConnectionWaypointPreparation | typeof _foblex_flow.PinchToZoomFinalize | typeof _foblex_flow.PinchToZoomPreparation | typeof _foblex_flow.SelectionAreaFinalize | typeof _foblex_flow.SelectionAreaPreparation | typeof _foblex_flow.ApplyChildResizeConstraints | typeof _foblex_flow.ApplyParentResizeConstraints | typeof _foblex_flow.CalculateChangedRectFromDifference | typeof _foblex_flow.CalculateDirectChildrenUnionRect | typeof _foblex_flow.CalculateResizeLimits | typeof _foblex_flow.ResizeNodeFinalize | typeof _foblex_flow.AttachResizeConnectionDragHandlersToNode | typeof _foblex_flow.ResizeNodePreparation | typeof _foblex_flow.RotateNodeFinalize | typeof _foblex_flow.RotateNodePreparation | typeof _foblex_flow.CalculateFlowPointFromMinimapPoint | typeof _foblex_flow.DragMinimapFinalize | typeof _foblex_flow.DragMinimapPreparation | typeof _foblex_flow.EmitSelectionChangeEvent | typeof _foblex_flow.GetNormalizedParentNodeRect | typeof _foblex_flow.IsArrayHasParentNode | typeof _foblex_flow.DetectConnectionsUnderDragNode | typeof _foblex_flow.StopAutoPan | typeof _foblex_flow.ScheduleAutoPanFrame | typeof _foblex_flow.RunAutoPanFrame | typeof _foblex_flow.SelectByPointer)[];

declare class AddDndToStoreRequest {
    fComponent: FDraggableBase;
    static readonly fToken: unique symbol;
    constructor(fComponent: FDraggableBase);
}

/**
 * Execution that adds a drag and drop directive to the FComponentsStore.
 */
declare class AddDndToStore implements IExecution<AddDndToStoreRequest, void> {
    private readonly _store;
    handle(request: AddDndToStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddDndToStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AddDndToStore>;
}

declare class OnPointerMoveRequest {
    event: IPointerEvent;
    static readonly fToken: unique symbol;
    constructor(event: IPointerEvent);
}

/**
 * Execution that handles pointer move events during a drag operation.
 * It calculates the difference between the current pointer position and the position
 * when the drag started, and updates the draggable items accordingly.
 */
declare class OnPointerMove implements IExecution<OnPointerMoveRequest, void> {
    private readonly _store;
    private readonly _dragContext;
    private get _hostElement();
    handle({ event }: OnPointerMoveRequest): void;
    private _setDifferenceToDraggableItems;
    private _getDifferenceBetweenPointerAndPointerDown;
    private _getPointerPositionInCanvas;
    static ɵfac: i0.ɵɵFactoryDeclaration<OnPointerMove, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OnPointerMove>;
}

declare class InitializeDragSequenceRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that initializes the drag sequence by resetting the FDraggableDataContext.
 */
declare class InitializeDragSequence implements IExecution<InitializeDragSequenceRequest, void> {
    private readonly _dragContext;
    handle(_: InitializeDragSequenceRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InitializeDragSequence, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InitializeDragSequence>;
}

declare class IsDragStartedRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that checks if a drag operation has started.
 */
declare class IsDragStarted implements IExecution<IsDragStartedRequest, boolean> {
    private readonly _store;
    handle(_: IsDragStartedRequest): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsDragStarted, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IsDragStarted>;
}

declare class PrepareDragSequenceRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that prepares the drag sequence by invoking the prepareDragSequence method on each draggable item.
 */
declare class PrepareDragSequence implements IExecution<PrepareDragSequenceRequest, void> {
    private readonly _mediator;
    private readonly _dragContext;
    handle(_: PrepareDragSequenceRequest): void;
    private _callPrepareDragSequence;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrepareDragSequence, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PrepareDragSequence>;
}

declare class RemoveDndFromStoreRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that removes the drag and drop directive from the FComponentsStore.
 */
declare class RemoveDndFromStore implements IExecution<RemoveDndFromStoreRequest, void> {
    private readonly _store;
    handle(_: RemoveDndFromStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveDndFromStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveDndFromStore>;
}

/**
 * Collection of all FDraggable feature executions.
 */
declare const F_DRAGGABLE_FEATURES: (typeof AddDndToStore | typeof OnPointerMove | typeof InitializeDragSequence | typeof PrepareDragSequence | typeof IsDragStarted | typeof RemoveDndFromStore)[];

declare const F_FLOW: InjectionToken<FFlowBase>;
declare abstract class FFlowBase implements IHasHostElement {
    abstract fId: InputSignal<string>;
    abstract fCache: InputSignalWithTransform<boolean, unknown>;
    abstract hostElement: HTMLElement;
    abstract fNodesRendered: OutputEmitterRef<string>;
    abstract fFullRendered: OutputEmitterRef<string>;
    /**
     * @deprecated Use `fFullRendered` instead.
     */
    abstract fLoaded: OutputEmitterRef<string>;
    abstract redraw(): void;
    abstract getState(options?: IFFlowStateOptions): IFFlowState;
}

declare class FFlowComponent extends FFlowBase implements OnInit, AfterContentInit, OnDestroy {
    private readonly _destroyRef;
    private readonly _mediator;
    private readonly _browser;
    private readonly _componentsStore;
    private readonly _cache;
    private readonly _injector;
    private readonly _flowConfig;
    fId: i0.InputSignal<string>;
    fCache: i0.InputSignalWithTransform<boolean, unknown>;
    readonly hostElement: any;
    fNodesRendered: i0.OutputEmitterRef<string>;
    fFullRendered: i0.OutputEmitterRef<string>;
    /**
     * @deprecated Use `fFullRendered` instead.
     */
    fLoaded: i0.OutputEmitterRef<string>;
    ngOnInit(): void;
    ngAfterContentInit(): void;
    _listenCacheChanges(): void;
    private _listenNodesChanges;
    private _listenConnectionsChanges;
    redraw(): void;
    reset(): void;
    getNodesBoundingBox(): IRect | null;
    getSelection(): ICurrentSelection;
    getPositionInFlow(position: IPoint): IRect;
    getState(options?: IFFlowStateOptions): IFFlowState;
    selectAll(): void;
    /**
     * Programmatically selects nodes and connections by their IDs.
     *
     * This method allows external components to control the selection state of the canvas.
     * Selected elements will appear visually highlighted. If `isSelectedChanged` is true,
     * the next user interaction (e.g., clicking the canvas) will emit a selection change event.
     *
     * @param nodes - An array of node IDs to select.
     * @param connections - An array of connection IDs to select.
     * @param isSelectedChanged - Optional. If true (default), marks the selection state as changed,
     * triggering a `fSelectionChange` event on the next user interaction.
     */
    select(nodes: string[], connections: string[], isSelectedChanged?: boolean): void;
    clearSelection(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FFlowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FFlowComponent, "f-flow", never, { "fId": { "alias": "fFlowId"; "required": false; "isSignal": true; }; "fCache": { "alias": "fCache"; "required": false; "isSignal": true; }; }, { "fNodesRendered": "fNodesRendered"; "fFullRendered": "fFullRendered"; "fLoaded": "fLoaded"; }, never, ["[fDefinitions]", "f-background", "f-line-alignment", "f-canvas", "f-selection-area", "*"], true, never>;
}

declare const F_FLOW_PROVIDERS: (typeof FFlowComponent)[];

declare class AddFlowToStoreRequest {
    readonly instance: FFlowBase;
    static readonly fToken: unique symbol;
    constructor(instance: FFlowBase);
}

/**
 * Execution that adds a Flow to the FComponentsStore.
 */
declare class AddFlowToStore implements IExecution<AddFlowToStoreRequest, void> {
    private readonly _store;
    private readonly _layoutController;
    handle({ instance }: AddFlowToStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddFlowToStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AddFlowToStore>;
}

declare class GetFlowRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that retrieves the current Flow from the FComponentsStore.
 */
declare class GetFlow implements IExecution<GetFlowRequest, FFlowBase> {
    private readonly _store;
    handle(_: GetFlowRequest): FFlowBase;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetFlow, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GetFlow>;
}

declare class CalculateConnectionsStateRequest {
    static readonly fToken: unique symbol;
}

interface IFFlowStateConnection {
    id: string;
    fOutputId: string;
    fInputId: string;
    fType: EFConnectionType | string;
    fBehavior: EFConnectionBehavior;
    isSelected: boolean;
    waypoints: IPoint[];
    fInputSide: EFConnectionConnectableSide;
    fOutputSide: EFConnectionConnectableSide;
}

/**
 * Execution that retrieves the current Flow state connections from the FComponentsStore.
 */
declare class CalculateConnectionsState implements IExecution<CalculateConnectionsStateRequest, IFFlowStateConnection[]> {
    private readonly _store;
    handle(_request: CalculateConnectionsStateRequest): IFFlowStateConnection[];
    private _mapToConnectionState;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateConnectionsState, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateConnectionsState>;
}

declare class CalculateNodesStateRequest {
    readonly component: Type<unknown>;
    readonly measuredSize: boolean;
    static readonly fToken: unique symbol;
    constructor(component: Type<unknown>, measuredSize?: boolean);
}

interface IFFlowStateConnector {
    id: string;
    fConnectableSide: EFConnectableSide;
}

interface IFFlowStateNode {
    id: string;
    parentId?: string;
    position: IPoint;
    size?: ISize;
    measuredSize?: ISize;
    rotate: number;
    fInputs: IFFlowStateConnector[];
    fOutputs: IFFlowStateConnector[];
    isSelected: boolean;
}

/**
 * Execution that retrieves the state of Flow nodes, including their position, size, inputs, outputs, and selection status.
 */
declare class CalculateNodesState implements IExecution<CalculateNodesStateRequest, IFFlowStateNode[]> {
    private readonly _store;
    private readonly _mediator;
    handle({ component, measuredSize }: CalculateNodesStateRequest): IFFlowStateNode[];
    private _getOutputs;
    private _getInputs;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateNodesState, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateNodesState>;
}

declare class CalculateFlowStateRequest {
    readonly measuredSize: boolean;
    static readonly fToken: unique symbol;
    constructor(measuredSize?: boolean);
}

interface IFFlowState {
    position: IPoint;
    scale: number;
    nodes: IFFlowStateNode[];
    groups: IFFlowStateNode[];
    connections: IFFlowStateConnection[];
}

/**
 * Execution that retrieves the current state of the Flow, including its position, scale, nodes, groups, and connections.
 */
declare class CalculateFlowState implements IExecution<CalculateFlowStateRequest, IFFlowState> {
    private readonly _mediator;
    private readonly _store;
    private get _canvas();
    private get _transform();
    private get _canvasPosition();
    handle({ measuredSize }: CalculateFlowStateRequest): IFFlowState;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateFlowState, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateFlowState>;
}

interface IFFlowStateOptions {
    measuredSize?: boolean;
}

/**
 * Providers for retrieving the current Flow state, including nodes, groups, and connections.
 */
declare const GET_FLOW_STATE_PROVIDERS: (typeof CalculateFlowState | typeof CalculateNodesState | typeof CalculateConnectionsState)[];

declare class RemoveFlowFromStoreRequest {
    readonly instance: FFlowBase;
    static readonly fToken: unique symbol;
    constructor(instance: FFlowBase);
}

/**
 * Execution that removes a Flow from the FComponentsStore.
 */
declare class RemoveFlowFromStore implements IExecution<RemoveFlowFromStoreRequest, void> {
    private readonly _store;
    private readonly _layoutController;
    handle({ instance }: RemoveFlowFromStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveFlowFromStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveFlowFromStore>;
}

declare class RenderLifecycleState {
    isNodesRendered: boolean;
    isFullRendered: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<RenderLifecycleState, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RenderLifecycleState>;
}

declare class NotifyNodesRenderedRequest {
    static readonly fToken: unique symbol;
}

declare class NotifyNodesRendered implements IExecution<NotifyNodesRenderedRequest, void> {
    private readonly _state;
    private readonly _fFlow;
    handle(_: NotifyNodesRenderedRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotifyNodesRendered, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NotifyNodesRendered>;
}

declare class NotifyFullRenderedRequest {
    static readonly fToken: unique symbol;
}

declare class NotifyFullRendered implements IExecution<NotifyFullRenderedRequest, void> {
    private readonly _state;
    private readonly _fFlow;
    handle(_: NotifyFullRenderedRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotifyFullRendered, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NotifyFullRendered>;
}

declare class WaitForConnectionsRenderedRequest {
    readonly targetConnectionsRevision: number;
    readonly targetNodesRevision: number;
    readonly callback: () => void;
    readonly destroyRef: DestroyRef;
    static readonly fToken: unique symbol;
    constructor(targetConnectionsRevision: number, targetNodesRevision: number, callback: () => void, destroyRef: DestroyRef);
}

declare class WaitForConnectionsRendered implements IExecution<WaitForConnectionsRenderedRequest, void> {
    private readonly _store;
    handle({ targetConnectionsRevision, targetNodesRevision, callback, destroyRef, }: WaitForConnectionsRenderedRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaitForConnectionsRendered, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WaitForConnectionsRendered>;
}

declare class ResetRenderLifecycleRequest {
    static readonly fToken: unique symbol;
}

declare class ResetRenderLifecycle implements IExecution<ResetRenderLifecycleRequest, void> {
    private readonly _state;
    handle(_: ResetRenderLifecycleRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResetRenderLifecycle, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResetRenderLifecycle>;
}

declare class QueueConnectionRedrawRequest {
    readonly destroyRef: DestroyRef;
    static readonly fToken: unique symbol;
    constructor(destroyRef: DestroyRef);
}

declare class QueueConnectionRedraw implements IExecution<QueueConnectionRedrawRequest, void> {
    private readonly _state;
    private readonly _store;
    private readonly _mediator;
    handle(request: QueueConnectionRedrawRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<QueueConnectionRedraw, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<QueueConnectionRedraw>;
}

declare class QueueConnectionRedrawState {
    isWaitingForViewportAnimation: boolean;
    pendingRedraw: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<QueueConnectionRedrawState, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<QueueConnectionRedrawState>;
}

/**
 * Providers for managing the Flow in the FComponentsStore.
 * This includes adding, retrieving, and removing the Flow,
 * as well as getting the Flow host element and its state.
 */
declare const F_FLOW_FEATURES: (typeof AddFlowToStore | typeof GetFlow | typeof _foblex_flow.CalculateFlowState | typeof _foblex_flow.CalculateNodesState | typeof _foblex_flow.CalculateConnectionsState | typeof RemoveFlowFromStore | typeof RenderLifecycleState | typeof NotifyNodesRendered | typeof NotifyFullRendered | typeof WaitForConnectionsRendered | typeof ResetRenderLifecycle | typeof QueueConnectionRedrawState | typeof QueueConnectionRedraw)[];

declare class AddNodeToStoreRequest {
    readonly nodeOrGroup: FNodeBase;
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup: FNodeBase);
}

/**
 * Execution that adds a Node to the FComponentsStore.
 */
declare class AddNodeToStore implements IExecution<AddNodeToStoreRequest, void> {
    private readonly _store;
    private readonly _mediator;
    handle({ nodeOrGroup }: AddNodeToStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddNodeToStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AddNodeToStore>;
}

declare class CalculateInputConnectionsRequest {
    readonly nodeOrGroup: FNodeBase;
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup: FNodeBase);
}

/**
 * Execution that calculates input connections for a given FNode.
 */
declare class CalculateInputConnections implements IExecution<CalculateInputConnectionsRequest, FConnectionBase[]> {
    private readonly _store;
    handle({ nodeOrGroup }: CalculateInputConnectionsRequest): FConnectionBase[];
    private _collectInputIds;
    private _collectConnections;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateInputConnections, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateInputConnections>;
}

declare class CalculateConnectableSideByConnectedPositionsRequest {
    readonly connector: FConnectorBase;
    readonly pointerPosition?: IPoint | undefined;
    static readonly fToken: unique symbol;
    constructor(connector: FConnectorBase, pointerPosition?: IPoint | undefined);
}

/**
 * Execution that calculates the connectable side for a connector
 * based on positions of connected connectors and allowed sides.
 */
declare class CalculateConnectableSideByConnectedPositions implements IExecution<CalculateConnectableSideByConnectedPositionsRequest, EFConnectableSide> {
    private readonly _mediator;
    /**
     * Entry point (hot path). Avoids intermediate arrays and redundant allocations.
     *
     * @param request - Contains the connector and optionally allowed sides.
     * @returns {EFConnectableSide} - The chosen connectable side.
     */
    handle({ connector, pointerPosition, }: CalculateConnectableSideByConnectedPositionsRequest): EFConnectableSide;
    private _accumulateConnectedCenters;
    private _getConnectorRect;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateConnectableSideByConnectedPositions, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateConnectableSideByConnectedPositions>;
}

declare class CalculateConnectableSideByInternalPositionRequest {
    readonly connector: FConnectorBase;
    static readonly fToken: unique symbol;
    constructor(connector: FConnectorBase);
}

/**
 * Injection token for configuring the side detection tolerance (in pixels).
 * A new side must beat the previous side by more than this value to switch.
 */
declare const CONNECTABLE_SIDE_EPSILON: InjectionToken<number>;
/**
 * Calculates the connectable side of a connector relative to its node host.
 *
 * Optimizations & behavior:
 * - Hysteresis via epsilon to avoid jitter near boundaries.
 * - Per-connector memoization using WeakMap (no leaks).
 * - During drag (isDragging === true) the last memorized side is returned immediately
 *   for maximum stability and performance; a safe fallback computes it if missing.
 */
declare class CalculateConnectableSideByInternalPosition implements IExecution<CalculateConnectableSideByInternalPositionRequest, EFConnectableSide> {
    private readonly _mediator;
    /**
     * Stores the last computed side per connector.
     * WeakMap ensures entries are garbage-collected with the connector objects.
     */
    private readonly _lastSide;
    /** Pixel threshold to prevent side switching unless the new side is sufficiently better. */
    private readonly _epsilon;
    /**
     * Entry point: returns the connectable side for a given connector.
     * If a drag is in progress, returns the last memorized side for stability.
     */
    handle({ connector, }: CalculateConnectableSideByInternalPositionRequest): EFConnectableSide;
    /**
     * Determines the side of the connector relative to the node host by
     * comparing distances from the connector's gravity center to each host edge.
     *
     * Hysteresis rule:
     * If the previously chosen side is within `epsilon` pixels of the new best side,
     * keep the previous side to avoid flicker.
     *
     * @param connectorHost - The connector element (HTML or SVG).
     * @param nodeHost - The parent node element (HTML or SVG).
     * @param connectorKey - The connector object, used as WeakMap key.
     * @returns The most stable connectable side.
     */
    private _getSideByDelta;
    /** Returns true if a drag operation is currently active. */
    private _isDragging;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateConnectableSideByInternalPosition, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateConnectableSideByInternalPosition>;
}

declare const CALCULATABLE_SIDES: {
    calculate: EFConnectableSide[];
    calculate_horizontal: EFConnectableSide[];
    calculate_vertical: EFConnectableSide[];
};

type TCalculateMode = EFConnectableSide.CALCULATE | EFConnectableSide.CALCULATE_HORIZONTAL | EFConnectableSide.CALCULATE_VERTICAL;

/**
 * Converts allowed sides array to a compact bit mask.
 * If not provided or empty -> all sides allowed.
 */

/**
 * Determines final side using ideal side first; if disallowed, picks best fallback.
 * Inputs are numbers to avoid object wrappers on hot path.
 */
declare function determineSide(selfX: number, selfY: number, avgX: number, avgY: number, allowed?: EFConnectableSide[]): EFConnectableSide;

/**
 * Checks if the given side is one of the calculate modes.
 * @param side The connectable side to check.
 * @returns True if the side is a calculate mode, false otherwise.
 */
declare function isCalculateMode(side: EFConnectableSide): boolean;

declare class CalculateConnectorsConnectableSidesRequest {
    readonly nodeOrGroup: FNodeBase;
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup: FNodeBase);
}

/**
 * Execution that calculates connectable sides for all connectors of a node.
 */
declare class CalculateConnectorsConnectableSides implements IExecution<CalculateConnectorsConnectableSidesRequest, void> {
    private readonly _mediator;
    /**
     * Orchestrates side calculation for all connectors of the given node.
     */
    handle({ nodeOrGroup }: CalculateConnectorsConnectableSidesRequest): void;
    /**
     * Resolves the connectable side for a connector quickly.
     * Avoids intermediate arrays and redundant allocations.
     */
    private _resolveSideForConnectorFast;
    /** Delegates to the connected-positions calculation execution. */
    private _calculateByConnectedPositions;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateConnectorsConnectableSides, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateConnectorsConnectableSides>;
}

declare class CalculateNodesBoundingBoxRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that calculates the bounding box of all nodes in the FComponentsStore.
 * It retrieves the rectangles of each node's host element and computes their union.
 */
declare class CalculateNodesBoundingBox implements IExecution<CalculateNodesBoundingBoxRequest, IRect | null> {
    private readonly _store;
    handle(_: CalculateNodesBoundingBoxRequest): IRect | null;
    private _nodesRects;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateNodesBoundingBox, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateNodesBoundingBox>;
}

declare class CalculateNodesBoundingBoxNormalizedPositionRequest {
    fNodes?: FNodeBase[] | undefined;
    static readonly fToken: unique symbol;
    constructor(fNodes?: FNodeBase[] | undefined);
}

/**
 * Execution that calculates the bounding box of all nodes in the FComponentsStore
 * and returns their normalized positions.
 * It retrieves the rectangles of each node's host element and computes their union.
 */
declare class CalculateNodesBoundingBoxNormalizedPosition implements IExecution<CalculateNodesBoundingBoxNormalizedPositionRequest, IRect | null> {
    private readonly _store;
    private readonly _mediator;
    handle(request: CalculateNodesBoundingBoxNormalizedPositionRequest): IRect | null;
    private _getNodesRects;
    private _getNodeRect;
    private _getElementRect;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateNodesBoundingBoxNormalizedPosition, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateNodesBoundingBoxNormalizedPosition>;
}

declare class CalculateOutputConnectionsRequest {
    readonly nodeOrGroup: FNodeBase;
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup: FNodeBase);
}

/**
 * Execution that calculates output connections for a given FNode.
 */
declare class CalculateOutputConnections implements IExecution<CalculateOutputConnectionsRequest, FConnectionBase[]> {
    private readonly _store;
    handle({ nodeOrGroup }: CalculateOutputConnectionsRequest): FConnectionBase[];
    private _collectOutputIds;
    private _collectConnections;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateOutputConnections, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateOutputConnections>;
}

declare class FitToChildNodesAndGroupsRequest {
    readonly nodeOrGroup: FNodeBase;
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup: FNodeBase);
}

declare class FitToChildNodesAndGroups implements IExecution<FitToChildNodesAndGroupsRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private get _nodes();
    handle({ nodeOrGroup }: FitToChildNodesAndGroupsRequest): void;
    private _calculateDirectChildren;
    private _unionRect;
    private _boundingRect;
    private _paddings;
    private _calculateChildrenBounding;
    static ɵfac: i0.ɵɵFactoryDeclaration<FitToChildNodesAndGroups, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FitToChildNodesAndGroups>;
}

declare class GetChildNodeIdsRequest {
    id?: string | null | undefined;
    static readonly fToken: unique symbol;
    constructor(id?: string | null | undefined);
}

/**
 * Execution that retrieves all child nodes of a given node in the Flow.
 */
declare class GetChildNodeIds implements IExecution<GetChildNodeIdsRequest, string[]> {
    private readonly _store;
    private get _allNodesAndGroups();
    handle(request: GetChildNodeIdsRequest): string[];
    private _collectDescendants;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetChildNodeIds, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GetChildNodeIds>;
}

declare class GetNodePaddingRequest {
    fNode: FNodeBase;
    rect: IRect;
    static readonly fToken: unique symbol;
    constructor(fNode: FNodeBase, rect: IRect);
}

/**
 * Execution that retrieves the padding data of a Node.
 * If the Node does not include padding, it returns [0, 0, 0, 0].
 */
declare class GetNodePadding implements IExecution<GetNodePaddingRequest, [
    number,
    number,
    number,
    number
]> {
    private readonly _browser;
    handle(request: GetNodePaddingRequest): [number, number, number, number];
    private _getPaddingData;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetNodePadding, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GetNodePadding>;
}

declare class GetParentNodesRequest {
    readonly nodeOrGroup: FNodeBase;
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup: FNodeBase);
}

/**
 * Execution that retrieves all parent nodes of a given node from the FComponentsStore.
 */
declare class GetParentNodes implements IExecution<GetParentNodesRequest, FNodeBase[]> {
    private readonly _store;
    handle({ nodeOrGroup }: GetParentNodesRequest): FNodeBase[];
    private _getParentNodes;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetParentNodes, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GetParentNodes>;
}

declare class UpdateNodeWhenStateOrSizeChangedRequest {
    readonly nodeOrGroup: FNodeBase;
    readonly destroyRef: DestroyRef;
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup: FNodeBase, destroyRef: DestroyRef);
}

/**
 * Execution that updates a node's connectors when its state or size changes.
 *
 * Content-driven resize path for the reflow-on-resize feature — after the
 * existing downstream updates (connector sides + fit-to-children), the
 * orchestrator is invoked. It consults its own baseline tracker (not the
 * global cache, which is disabled by default) and short-circuits when the
 * feature is not active.
 */
declare class UpdateNodeWhenStateOrSizeChanged implements IExecution<UpdateNodeWhenStateOrSizeChangedRequest, void> {
    private readonly _mediator;
    private readonly _reflowOrchestrator;
    /**
     * Handles the request to update the node's connectors based on state or size changes.
     * It listens for resize events and recalculates the connectable sides of the connectors.
     * @param request
     */
    handle({ nodeOrGroup, destroyRef }: UpdateNodeWhenStateOrSizeChangedRequest): void;
    private _isDragging;
    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateNodeWhenStateOrSizeChanged, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UpdateNodeWhenStateOrSizeChanged>;
}

declare class RemoveNodeFromStoreRequest {
    readonly instance: FNodeBase;
    static readonly fToken: unique symbol;
    constructor(instance: FNodeBase);
}

/**
 * Execution that removes a node from the FComponentsStore.
 */
declare class RemoveNodeFromStore implements IExecution<RemoveNodeFromStoreRequest, void> {
    private readonly _store;
    private readonly _mediator;
    handle({ instance }: RemoveNodeFromStoreRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveNodeFromStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RemoveNodeFromStore>;
}

/**
 * This file exports all the node-related executions that can be used in the F-Flow domain.
 */
declare const F_NODE_FEATURES: (typeof AddNodeToStore | typeof CalculateConnectableSideByConnectedPositions | typeof CalculateConnectableSideByInternalPosition | typeof CalculateInputConnections | typeof CalculateConnectorsConnectableSides | typeof CalculateNodesBoundingBox | typeof CalculateNodesBoundingBoxNormalizedPosition | typeof CalculateOutputConnections | typeof FitToChildNodesAndGroups | typeof GetChildNodeIds | typeof GetNodePadding | typeof GetParentNodes | typeof UpdateNodeWhenStateOrSizeChanged | typeof RemoveNodeFromStore)[];

declare class ClearSelectionRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that clears the selection of items in the FDraggableDataContext.
 */
declare class ClearSelection implements IExecution<ClearSelectionRequest, void> {
    private _dragContext;
    handle(_: ClearSelectionRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClearSelection, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ClearSelection>;
}

interface ICanBeSelectedElementAndRect {
    element: ISelectable;
    fRect: IRect;
}

/**
 * Execution that retrieves elements that can be selected in the Flow, along with their bounding rectangles.
 * It filters out elements that are already selected in the FDraggableDataContext.
 */
declare class CalculateSelectableItems implements IExecution<void, ICanBeSelectedElementAndRect[]> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragContext;
    private get _nodes();
    private get _connections();
    handle(): ICanBeSelectedElementAndRect[];
    /**
     * Retrieves nodes with their bounding rectangles that can be selected.
     * @private
     */
    private _nodeRects;
    /**
     * Retrieves connections with their bounding rectangles that can be selected.
     * @private
     */
    private _connectionRects;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateSelectableItems, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateSelectableItems>;
}

declare class CalculateSelectableItemsRequest {
    static readonly fToken: unique symbol;
}

declare class GetCurrentSelectionRequest {
    static readonly fToken: unique symbol;
}

interface ICurrentSelection {
    fNodeIds: string[];
    fGroupIds: string[];
    fConnectionIds: string[];
}

/**
 * Execution that retrieves the current selection of items in the FDraggableDataContext.
 */
declare class GetCurrentSelection implements IExecution<GetCurrentSelectionRequest, ICurrentSelection> {
    private _dragContext;
    handle(): ICurrentSelection;
    private _getSelectedNodes;
    private _getSelectedGroups;
    private _getSelectedConnections;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetCurrentSelection, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GetCurrentSelection>;
}

declare class SelectRequest {
    nodes: string[];
    connections: string[];
    isSelectedChanged: boolean;
    static readonly fToken: unique symbol;
    constructor(nodes: string[], connections: string[], isSelectedChanged?: boolean);
}

/**
 * Execution that handles the selection of nodes and connections in the FFlow.
 */
declare class Select implements IExecution<SelectRequest, void> {
    private readonly _dragContext;
    private readonly _store;
    handle(request: SelectRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<Select, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Select>;
}

declare class SelectAllRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that selects all components in the FComponentsStore.
 * It marks all nodes and connections as selected and updates the selected items in the FDraggableDataContext.
 */
declare class SelectAll implements IExecution<SelectAllRequest, void> {
    private readonly _dragSession;
    private readonly _store;
    handle(_request: SelectAllRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectAll, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SelectAll>;
}

declare class SelectAndUpdateNodeLayerRequest {
    readonly nodeOrGroup: FNodeBase;
    static readonly fToken: unique symbol;
    constructor(nodeOrGroup: FNodeBase);
}

/**
 * Execution that selects a node and updates its layer along with its children.
 * It checks if the node is already selected, and if not, it marks it as selected
 * and updates the layers of the node and its children.
 */
declare class SelectAndUpdateNodeLayer implements IHandler<SelectAndUpdateNodeLayerRequest, void> {
    private readonly _dragSession;
    private readonly _mediator;
    handle({ nodeOrGroup }: SelectAndUpdateNodeLayerRequest): void;
    private _selectNodeIfNotSelected;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectAndUpdateNodeLayer, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SelectAndUpdateNodeLayer>;
}

/**
 * This module provides a collection of executions related to selection features in the FFlow domain.
 */
declare const F_SELECTION_FEATURES: (typeof ClearSelection | typeof CalculateSelectableItems | typeof GetCurrentSelection | typeof Select | typeof SelectAll | typeof SelectAndUpdateNodeLayer)[];

declare class ResetZoomRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that resets the zoom level of the FCanvas.
 */
declare class ResetZoom implements IExecution<ResetZoomRequest, void> {
    private readonly _store;
    private get _canvas();
    handle(_request: ResetZoomRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResetZoom, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResetZoom>;
}

declare class SetZoomRequest {
    readonly position: IPoint;
    readonly step: number;
    readonly direction: number;
    readonly animate: boolean;
    static readonly fToken: unique symbol;
    constructor(position: IPoint, step: number, direction: number, animate?: boolean);
}

/**
 * Execution that sets the zoom level of the FCanvas based on the provided request.
 * It adjusts the zoom level by a specified step and direction, ensuring it stays within defined limits.
 */
declare class SetZoom implements IExecution<SetZoomRequest, void> {
    private readonly _mediator;
    private readonly _store;
    private readonly _dragContext;
    private get _flowHost();
    private get _canvas();
    private get _zoomComponent();
    private get _isDragStarted();
    handle(request: SetZoomRequest): void;
    private _clamp;
    private _castPositionToFlow;
    private _getDragZoomMode;
    private _rebaseDragContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<SetZoom, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SetZoom>;
}

/**
 * Collection of all FZoom feature executions.
 * These executions handle the addition, removal, and resetting of zoom levels
 * in the FComponentsStore.
 */
declare const F_ZOOM_FEATURES: (typeof ResetZoom | typeof SetZoom)[];

declare class MinimapDrawNodesRequest {
    static readonly fToken: unique symbol;
}

declare class MinimapDrawNodes implements IExecution<MinimapDrawNodesRequest, SVGRectElement[]> {
    private readonly _browser;
    private readonly _store;
    handle(_: MinimapDrawNodesRequest): SVGRectElement[];
    private _renderNode;
    private _nodeRect;
    private _minimapClasses;
    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapDrawNodes, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MinimapDrawNodes>;
}

interface IMinimapViewport {
    scale: number;
    viewBox: IRect;
}

declare class MinimapCalculateViewportRequest {
    readonly svg: SVGSVGElement;
    readonly minSize: number;
    static readonly fToken: unique symbol;
    constructor(svg: SVGSVGElement, minSize: number);
}

declare class MinimapCalculateViewport implements IExecution<MinimapCalculateViewportRequest, IMinimapViewport> {
    private readonly _mediator;
    private readonly _store;
    handle({ svg, minSize }: MinimapCalculateViewportRequest): IMinimapViewport;
    private _contentRectInMinimapSpace;
    private _nodesBoundingBox;
    private _minimapRectInFlowSpace;
    private _viewportScale;
    private _viewportViewBox;
    private _viewportSize;
    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapCalculateViewport, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MinimapCalculateViewport>;
}

declare class MinimapCalculateViewRectRequest {
    static readonly fToken: unique symbol;
}

declare class MinimapCalculateViewRect implements IExecution<MinimapCalculateViewRectRequest, IRect> {
    private readonly _store;
    handle(_request: MinimapCalculateViewRectRequest): IRect;
    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapCalculateViewRect, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MinimapCalculateViewRect>;
}

declare class FMinimapState {
    element: SVGSVGElement;
    scale: number;
    viewBox: IRect;
    constructor(element: SVGSVGElement, scale?: number, viewBox?: IRect);
}

declare const F_MINIMAP_FEATURES: (typeof MinimapDrawNodes | typeof MinimapCalculateViewport | typeof MinimapCalculateViewRect)[];

declare class GetDeepChildrenNodesAndGroupsRequest {
    readonly nodeOrGroupId: string;
    static readonly fToken: unique symbol;
    constructor(nodeOrGroupId: string);
}

/**
 * Execution that retrieves all deep children nodes and groups from the FComponentsStore.
 * It traverses the node hierarchy to find all descendants of a given node.
 */
declare class GetDeepChildrenNodesAndGroups implements IExecution<GetDeepChildrenNodesAndGroupsRequest, FNodeBase[]> {
    private readonly _store;
    handle({ nodeOrGroupId }: GetDeepChildrenNodesAndGroupsRequest): FNodeBase[];
    private _getChildrenNodes;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetDeepChildrenNodesAndGroups, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GetDeepChildrenNodesAndGroups>;
}

declare class GetNormalizedConnectorRectRequest {
    readonly element: HTMLElement | SVGElement;
    readonly cache: boolean;
    static readonly fToken: unique symbol;
    constructor(element: HTMLElement | SVGElement, cache?: boolean);
}

/**
 * Execution that retrieves the normalized rectangle of a connector.
 * It calculates the rectangle based on the element's position and size,
 * adjusting for the canvas transformation and element offsets.
 */
declare class GetNormalizedConnectorRect implements IExecution<GetNormalizedConnectorRectRequest, IRoundedRect> {
    private readonly _store;
    private readonly _mediator;
    private readonly _browser;
    private get _transform();
    handle({ element, cache }: GetNormalizedConnectorRectRequest): IRoundedRect;
    private _getElementRoundedRect;
    private _getRoundedRect;
    private _getComputedStyle;
    private _toPixels;
    private _getSystemRadius;
    /**
     * Mirrors CSS border-radius normalization so oversized values like `999px`
     * collapse to the largest valid circular radii for the current rect.
     */
    private _normalizeCircularBorderRadii;
    private _getRadiusScaleFactor;
    private _normalizePosition;
    private _unscaleSize;
    private _getUnscaledRect;
    private _unscaleRadius;
    private _getOffsetSize;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetNormalizedConnectorRect, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GetNormalizedConnectorRect>;
}

declare class GetNormalizedElementRectRequest {
    readonly element: HTMLElement | SVGElement;
    static readonly fToken: unique symbol;
    constructor(element: HTMLElement | SVGElement);
}

/**
 * Execution that retrieves the normalized rectangle of an element.
 * It calculates the rectangle based on the element's position and size,
 * adjusting for the canvas transformation and element offsets.
 */
declare class GetNormalizedElementRect implements IExecution<GetNormalizedElementRectRequest, IRect> {
    private readonly _store;
    private readonly _mediator;
    private get _transform();
    handle({ element }: GetNormalizedElementRectRequest): IRect;
    private _fromCenter;
    private _normalizePosition;
    private _unscaleSize;
    private _getUnscaledRect;
    private _getOffsetSize;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetNormalizedElementRect, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GetNormalizedElementRect>;
}

declare class GetNormalizedPointRequest {
    readonly position: IPoint;
    static readonly fToken: unique symbol;
    constructor(position: IPoint);
}

/**
 * Execution that retrieves the normalized point of a position.
 * It calculates the point based on the position's transformation
 * and the canvas transformation.
 */
declare class GetNormalizedPoint implements IExecution<GetNormalizedPointRequest, IPoint> {
    private readonly _store;
    handle({ position }: GetNormalizedPointRequest): IPoint;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetNormalizedPoint, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GetNormalizedPoint>;
}

declare class SortNodeLayersRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that sorts node layers by their parent nodes in the FCanvas.
 * It retrieves all groups, sorts their children nodes based on their current order,
 * and moves them to maintain the correct hierarchy.
 */
declare class SortNodeLayers implements IExecution<SortNodeLayersRequest, void> {
    private readonly _store;
    private readonly _mediator;
    private readonly _browser;
    private get _canvas();
    private get _groupsContainer();
    private get _nodesContainer();
    private get _fNodeElements();
    handle(_: SortNodeLayersRequest): void;
    private _getGroups;
    private _getSortedChildrenNodes;
    private _getChildrenNodes;
    private _moveChildrenNodes;
    static ɵfac: i0.ɵɵFactoryDeclaration<SortNodeLayers, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SortNodeLayers>;
}

declare class SortItemsByParentRequest {
    readonly itemsContainer: HTMLElement;
    static readonly fToken: unique symbol;
    constructor(itemsContainer: HTMLElement);
}

/**
 * Execution that sorts items by their parent nodes in the FItemsContainer.
 * It retrieves all items within the container, sorts their children based on their current order,
 * and moves them to maintain the correct hierarchy.
 */
declare class SortItemsByParent implements IExecution<SortItemsByParentRequest, void> {
    private readonly _store;
    private readonly _browser;
    handle({ itemsContainer }: SortItemsByParentRequest): void;
    private _buildPositions;
    private _getSortedChildrenBeforeParent;
    private _buildChildrenByParentId;
    private _getDeepChildren;
    private _moveBeforeNextSibling;
    static ɵfac: i0.ɵɵFactoryDeclaration<SortItemsByParent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SortItemsByParent>;
}

declare class SortItemLayersRequest {
    static readonly fToken: unique symbol;
}

/**
 * Execution that sorts item layers in the FCanvas by their parent nodes.
 * This execution is registered to handle SortItemLayersRequest and
 * ensures that items are sorted correctly within their parent nodes.
 * It first sorts items by their parent nodes in the groups container,
 * then sorts the node layers, and finally sorts items by their parent nodes in the nodes container.
 */
declare class SortItemLayers implements IExecution<SortItemLayersRequest, void> {
    private readonly _store;
    private readonly _mediator;
    private get _canvas();
    handle(_request: SortItemLayersRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SortItemLayers, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SortItemLayers>;
}

declare class MoveFrontElementsBeforeTargetElementRequest {
    readonly fItemsContainer: HTMLElement;
    readonly allElements: Element[];
    readonly elementsThatShouldBeInFront: Element[];
    readonly targetIndex: number;
    static readonly fToken: unique symbol;
    constructor(fItemsContainer: HTMLElement, // fGroupsContainer || fNodesContainer || fConnectionsContainer
    allElements: Element[], elementsThatShouldBeInFront: Element[], targetIndex: number);
}

/**
 * Execution that moves elements in the FItemsContainer before a target element.
 * It removes elements that should not be in front and inserts them before the target element.
 */
declare class MoveFrontElementsBeforeTargetElement implements IExecution<MoveFrontElementsBeforeTargetElementRequest, void> {
    handle(request: MoveFrontElementsBeforeTargetElementRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MoveFrontElementsBeforeTargetElement, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MoveFrontElementsBeforeTargetElement>;
}

declare class UpdateItemAndChildrenLayersRequest {
    item: ISelectable;
    itemContainer: HTMLElement;
    static readonly fToken: unique symbol;
    constructor(item: ISelectable, itemContainer: HTMLElement);
}

/**
 * Execution that updates the layers of an item and its children in the FCanvas.
 * It handles different item containers (groups, nodes, connections) and updates their layers accordingly.
 */
declare class UpdateItemAndChildrenLayers implements IExecution<UpdateItemAndChildrenLayersRequest, void> {
    private readonly _store;
    private readonly _mediator;
    private get _canvas();
    private get _groupsContainer();
    private get _nodesContainer();
    private get _connectionsContainer();
    handle(request: UpdateItemAndChildrenLayersRequest): void;
    private _handleGroup;
    private _handleNode;
    private _handleConnection;
    private _updateLayers;
    private _isAnythingNeedToBeMoved;
    private _getChildrenGroups;
    private _getChildrenNodes;
    private _getChildrenNodesAndGroups;
    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateItemAndChildrenLayers, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UpdateItemAndChildrenLayers>;
}

declare function createSVGElement<K extends keyof SVGElementTagNameMap>(tag: K, fBrowser: BrowserService): SVGElementTagNameMap[K];

declare const F_CSS_CLASS: {
    DRAG_AND_DROP: {
        DRAGGING: string;
        CONNECTIONS_DRAGGING: string;
    };
    GROUPING: {
        OVER_BOUNDARY: string;
        DROP_ACTIVE: string;
    };
    CONNECTOR: {
        OUTPUT_CONNECTED: string;
        OUTPUT_NOT_CONNECTABLE: string;
        INPUT_CONNECTED: string;
        INPUT_NOT_CONNECTABLE: string;
        CONNECTABLE: string;
    };
};

type FEventTrigger = (event: FTriggerEvent) => boolean;
type FTriggerEvent = MouseEvent | TouchEvent | WheelEvent;
declare function isValidEventTrigger(event: FTriggerEvent, fTrigger: FEventTrigger): boolean;
declare function defaultEventTrigger(_event: FTriggerEvent): boolean;

declare function isMobile(): boolean;

declare function Deprecated(newMethodName: string, removalVersion?: string): MethodDecorator;

declare function LogExecutionTime(label?: string): MethodDecorator;

/**
 * This module provides a collection of common providers for the FFlow domain.
 * It includes features related to canvas, connections, background, connectors,
 * draggable elements, flow, line alignment, nodes, selection, zoom,
 * and various utility executions.
 */
declare const COMMON_PROVIDERS: (typeof _foblex_flow.FCache | typeof _foblex_flow.InvalidateFCacheNode | typeof _foblex_flow.RegisterFCacheNode | typeof _foblex_flow.UnregisterFCacheNode | typeof _foblex_flow.RegisterFCacheConnector | typeof _foblex_flow.UnregisterFCacheConnector | typeof _foblex_flow.GetCachedFCacheRect | typeof _foblex_flow.SetFCacheConnectorRect | typeof _foblex_flow.SetFCacheNodeRect | typeof _foblex_flow.UpdateFCacheRectByElement | typeof GetNormalizedElementRect | typeof _foblex_flow.AddCanvasToStore | typeof _foblex_flow.CenterGroupOrNode | typeof _foblex_flow.FitToFlow | typeof _foblex_flow.InputCanvasPosition | typeof _foblex_flow.InputCanvasScale | typeof _foblex_flow.RedrawCanvasWithAnimation | typeof _foblex_flow.ResetScaleAndCenter | typeof _foblex_flow.UpdateScale | typeof _foblex_flow.ConnectionRedrawState | typeof _foblex_flow.ConnectionWorkerState | typeof _foblex_flow.AddConnectionForCreateToStore | typeof _foblex_flow.AddConnectionMarkerToStore | typeof _foblex_flow.AddConnectionToStore | typeof _foblex_flow.AddSnapConnectionToStore | typeof _foblex_flow.CreateConnectionMarkers | typeof _foblex_flow.ApplyConnectionWorkerResult | typeof _foblex_flow.ApplyConnectionRender | typeof _foblex_flow.BuildConnectionLine | typeof _foblex_flow.BuildConnectionWorkerBatch | typeof _foblex_flow.BuildConnectionWorkerPayloadItem | typeof _foblex_flow.CompleteConnectionRedraw | typeof _foblex_flow.DisableConnectionWorker | typeof _foblex_flow.HandleConnectionWorkerMessage | typeof _foblex_flow.IsConnectionRedrawCurrent | typeof _foblex_flow.MarkConnectionConnectorsAsConnected | typeof _foblex_flow.RenderConnection | typeof _foblex_flow.RenderConnectionFromGeometry | typeof _foblex_flow.RenderConnectionWithLine | typeof _foblex_flow.ResolveConnectionEndpointRect | typeof _foblex_flow.ResolveConnectionEndpointRotationContext | typeof _foblex_flow.ResolveConnectionEndpoints | typeof _foblex_flow.ResolveConnectionGeometry | typeof _foblex_flow.ResetConnectionWorkerRuntime | typeof _foblex_flow.RunConnectionRedrawSlice | typeof _foblex_flow.RunConnectionWorker | typeof _foblex_flow.RunConnectionWorkerBatch | typeof _foblex_flow.ShouldUseConnectionWorker | typeof _foblex_flow.StartConnectionWorkerRedraw | typeof _foblex_flow.RemoveConnectionFromStore | typeof _foblex_flow.RemoveConnectionMarkerFromStore | typeof _foblex_flow.RemoveConnectionWaypoint | typeof _foblex_flow.AddPatternToBackground | typeof _foblex_flow.SetBackgroundTransform | typeof _foblex_flow.AddConnectorToStore | typeof _foblex_flow.RemoveConnectorFromStore | typeof _foblex_flow.CalculateClosestConnector | typeof _foblex_flow.FindConnectableConnectorUsingPriorityAndPosition | typeof _foblex_flow.CalculateSourceConnectorsToConnect | typeof _foblex_flow.CalculateTargetConnectorsToConnect | typeof _foblex_flow.GetConnectorRectReference | typeof _foblex_flow.MarkConnectableConnectors | typeof _foblex_flow.UnmarkConnectableConnectors | typeof _foblex_flow.AddDndToStore | typeof _foblex_flow.OnPointerMove | typeof _foblex_flow.AddFlowToStore | typeof _foblex_flow.CalculateFlowState | typeof _foblex_flow.CalculateNodesState | typeof _foblex_flow.RemoveFlowFromStore | typeof _foblex_flow.RenderLifecycleState | typeof _foblex_flow.WaitForConnectionsRendered | typeof _foblex_flow.QueueConnectionRedrawState | typeof _foblex_flow.QueueConnectionRedraw | typeof _foblex_flow.AddNodeToStore | typeof _foblex_flow.CalculateConnectableSideByConnectedPositions | typeof _foblex_flow.CalculateConnectableSideByInternalPosition | typeof _foblex_flow.CalculateInputConnections | typeof _foblex_flow.CalculateConnectorsConnectableSides | typeof _foblex_flow.CalculateNodesBoundingBoxNormalizedPosition | typeof _foblex_flow.CalculateOutputConnections | typeof _foblex_flow.FitToChildNodesAndGroups | typeof _foblex_flow.GetChildNodeIds | typeof _foblex_flow.GetNodePadding | typeof _foblex_flow.GetParentNodes | typeof _foblex_flow.UpdateNodeWhenStateOrSizeChanged | typeof _foblex_flow.RemoveNodeFromStore | typeof _foblex_flow.Select | typeof _foblex_flow.SelectAndUpdateNodeLayer | typeof _foblex_flow.SetZoom | typeof _foblex_flow.MinimapCalculateViewport | typeof GetDeepChildrenNodesAndGroups | typeof GetNormalizedConnectorRect | typeof GetNormalizedPoint | typeof SortItemsByParent | typeof UpdateItemAndChildrenLayers | typeof MoveFrontElementsBeforeTargetElement)[];

declare function transitionEnd(element: HTMLElement, callback: (event: TransitionEvent) => void): void;

declare enum EFLayoutDirection {
    TOP_BOTTOM = "TOP_BOTTOM",
    BOTTOM_TOP = "BOTTOM_TOP",
    LEFT_RIGHT = "LEFT_RIGHT",
    RIGHT_LEFT = "RIGHT_LEFT"
}

declare enum EFLayoutMode {
    MANUAL = "manual",
    AUTO = "auto"
}

interface IFLayoutOptions<TAlgorithm extends string = string> {
    direction: EFLayoutDirection;
    nodeGap: number;
    layerGap: number;
    algorithm: TAlgorithm;
    defaultNodeSize: ISize;
}

interface IFLayoutAlgorithmOptions<TAlgorithm extends string = string> extends IFLayoutOptions<TAlgorithm> {
}

type IFLayoutCalculationOptions<TOptions extends IFLayoutOptions<string> = IFLayoutOptions<string>> = Partial<TOptions> & {
    flowId?: string;
    mode?: EFLayoutMode;
};

interface IFLayoutConnection {
    source: string;
    target: string;
}

interface IFLayoutNode {
    id: string;
    size?: ISize;
}

interface IFLayoutGraph<TNode extends IFLayoutNode = IFLayoutNode, TConnection extends IFLayoutConnection = IFLayoutConnection> {
    nodes: TNode[];
    connections: TConnection[];
}

interface IFLayoutNodePosition {
    id: string;
    position: IPoint;
}

interface IFLayoutWritebackPayload {
    flowId: string;
    nodes: IFLayoutNodePosition[];
    groups: IFLayoutNodePosition[];
}
type TFLayoutWritebackHandler = (payload: IFLayoutWritebackPayload) => void;

declare const F_LAYOUT_OPTIONS: InjectionToken<IFLayoutProviderConfig<IFLayoutOptions<string>>>;
interface IFLayoutProviderConfig<TOptions extends IFLayoutOptions<string> = IFLayoutOptions<string>> {
    mode?: EFLayoutMode;
    writeback?: TFLayoutWritebackHandler | null;
    options?: Partial<TOptions>;
}

interface IFLayoutResult {
    nodes: IFLayoutNodePosition[];
}

declare function mergeLayoutNodes(nodes: IFLayoutNode[], positions: Map<string, IPoint>): IFLayoutNodePosition[];

declare const F_LAYOUT: InjectionToken<FLayoutEngine<IFLayoutOptions<string>>>;
type TReadonlyDeep<T> = {
    readonly [K in keyof T]: T[K] extends object ? TReadonlyDeep<T[K]> : T[K];
};
declare abstract class FLayoutEngine<TOptions extends IFLayoutOptions<string> = IFLayoutOptions<string>> {
    private readonly _controller;
    private readonly _config;
    private _interactiveOptions;
    private _mode;
    private _writeback;
    private _defaultOptions;
    readonly interactiveOptions: Signal<TReadonlyDeep<TOptions>>;
    protected constructor(defaultOptions: TOptions);
    setMode(mode: EFLayoutMode): void;
    getMode(): EFLayoutMode;
    setWriteback(handler: TFLayoutWritebackHandler | null): void;
    getWriteback(): TFLayoutWritebackHandler | null;
    setInteractiveOptions(options: Partial<TOptions>): void;
    relayout(flowId?: string): Promise<void>;
    getProviderConfig(): IFLayoutProviderConfig<TOptions>;
    protected resolveLayoutOptions(options?: IFLayoutCalculationOptions<TOptions>): TOptions;
    protected abstract mergeOptions(currentOptions: TOptions, nextOptions?: Partial<TOptions>): TOptions;
    abstract calculate(nodes: IFLayoutNode[], connections: IFLayoutConnection[], options?: IFLayoutCalculationOptions<TOptions>): Promise<IFLayoutResult>;
}

interface FHasId {
    fId: Signal<string>;
}
/**
 * Stores instances indexed by `fId()` + preserves insertion order.
 *
 * - `get(id)` returns `undefined`
 * - `require(id)` throws with a readable message that includes `kind`
 */
declare abstract class FIdRegistryBase<TInstance extends FHasId> {
    private readonly _items;
    private readonly _byId;
    /** Used only for error messages. Example: "node", "connection", "input". */
    protected abstract readonly kind: string;
    get(id: string): TInstance | undefined;
    require(id: string): TInstance;
    has(id: string): boolean;
    getAll(): TInstance[];
    size(): number;
    /**
     * Adds an instance.
     * If instance with the same id already exists — throws (keeps data consistent).
     */
    add(instance: TInstance): void;
    addMany(instances: readonly TInstance[]): void;
    /**
     * Removes by instance reference (fast path).
     * Returns `true` if removed, `false` if not found.
     */
    remove(instance: TInstance): boolean;
    /**
     * Removes by id.
     * Returns removed instance (if existed).
     */
    removeById(id: string): TInstance | undefined;
    /**
     * Clears registry (does NOT touch other state outside).
     */
    clear(): void;
}

type FInstanceKey<T> = {
    readonly name: string;
    readonly __type?: T;
};
declare function fInstanceKey<T>(name: string): FInstanceKey<T>;
declare class FSingleRegistryBase {
    private readonly _instances;
    get<T>(key: FInstanceKey<T>): T | undefined;
    require<T>(key: FInstanceKey<T>): T;
    has(key: FInstanceKey<unknown>): boolean;
    add<T>(key: FInstanceKey<T>, instance: T): void;
    remove(key: FInstanceKey<unknown>): boolean;
    clear(): void;
}

declare class FConnectorRegistry<TInstance extends FHasId> extends FIdRegistryBase<TInstance> {
    protected kind: string;
    constructor(kind: string);
}

declare class FConnectionMarkerRegistry extends FIdRegistryBase<FConnectionMarkerBase> {
    protected readonly kind = "Connection Marker";
}

declare class FConnectionRegistry extends FIdRegistryBase<FConnectionBase> {
    protected readonly kind = "Connection";
    private _instancesForCreate;
    private _instancesForSnap;
    getForSnap(): FSnapConnectionComponent | undefined;
    getForCreate(): FConnectionForCreateComponent | undefined;
    addForCreate(instance: FConnectionForCreateComponent): void;
    addForSnap(instance: FSnapConnectionComponent): void;
    removeInstanceForCreate(): void;
    removeInstanceForSnap(): void;
}

declare class FNodeRegistry extends FIdRegistryBase<FNodeBase> {
    protected readonly kind = "Node";
}

declare class ListenConnectionsChangesRequest {
    readonly notifyOnSubscribe: boolean;
    static readonly fToken: unique symbol;
    constructor(notifyOnSubscribe?: boolean);
}

declare class ListenConnectionsChanges implements IExecution<ListenConnectionsChangesRequest, FChannelHub> {
    private readonly _store;
    handle({ notifyOnSubscribe }: ListenConnectionsChangesRequest): FChannelHub;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListenConnectionsChanges, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ListenConnectionsChanges>;
}

declare class ListenNodesChangesRequest {
    static readonly fToken: unique symbol;
}

declare class ListenNodesChanges implements IExecution<ListenNodesChangesRequest, FChannelHub> {
    private readonly _store;
    handle(_: ListenNodesChangesRequest): FChannelHub;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListenNodesChanges, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ListenNodesChanges>;
}

declare class ListenTransformChangesRequest {
    static readonly fToken: unique symbol;
}

declare class ListenTransformChanges implements IExecution<ListenTransformChangesRequest, FChannelHub> {
    private readonly _store;
    handle(_: ListenTransformChangesRequest): FChannelHub;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListenTransformChanges, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ListenTransformChanges>;
}

declare class EmitConnectionsChangesRequest {
    static readonly fToken: unique symbol;
}

declare class EmitConnectionsChanges implements IExecution<EmitConnectionsChangesRequest, void> {
    private readonly _store;
    handle(_: EmitConnectionsChangesRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmitConnectionsChanges, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EmitConnectionsChanges>;
}

declare class NotifyTransformChangedRequest {
    static readonly fToken: unique symbol;
}

declare class NotifyTransformChanged implements IExecution<NotifyTransformChangedRequest, void> {
    private readonly _store;
    handle(_request: NotifyTransformChangedRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotifyTransformChanged, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NotifyTransformChanged>;
}

declare class RegisterPluginInstanceRequest {
    readonly key: FInstanceKey<unknown>;
    readonly instance: unknown;
    static readonly fToken: unique symbol;
    constructor(key: FInstanceKey<unknown>, instance: unknown);
}

/**
 * Execution that adds a line alignment to the FComponentsStore.
 */
declare class RegisterPluginInstance implements IExecution<RegisterPluginInstanceRequest, void> {
    private readonly _store;
    handle({ key, instance }: RegisterPluginInstanceRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterPluginInstance, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RegisterPluginInstance>;
}

declare class RemovePluginInstanceRequest {
    readonly key: FInstanceKey<unknown>;
    static readonly fToken: unique symbol;
    constructor(key: FInstanceKey<unknown>);
}

/**
 * Execution that removes a line alignment from the FComponentsStore.
 */
declare class RemovePluginInstance implements IExecution<RemovePluginInstanceRequest, void> {
    private readonly _store;
    handle({ key }: RemovePluginInstanceRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RemovePluginInstance, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RemovePluginInstance>;
}

declare enum EFZoomDirection {
    ZOOM_IN = 1,
    ZOOM_OUT = -1
}

declare const F_ZOOM: InjectionToken<FZoomBase>;
declare abstract class FZoomBase {
    abstract minimum: number;
    abstract maximum: number;
    abstract step: number;
    abstract dblClickStep: number;
}

declare class FZoomDirective extends FZoomBase implements OnInit, AfterViewInit, OnDestroy {
    private readonly _mediator;
    private readonly _injector;
    private readonly _store;
    private _triggersListener;
    readonly isEnabled: i0.InputSignalWithTransform<boolean, unknown>;
    fWheelTrigger: FEventTrigger;
    fDblClickTrigger: FEventTrigger;
    minimum: number;
    maximum: number;
    step: number;
    dblClickStep: number;
    private get _flowHost();
    private get _canvas();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private _listenZoomEnabledChanges;
    private _listenTriggers;
    private _onWheel;
    private _normalizeWheelStep;
    private _calculateDirection;
    private _onDoubleClick;
    private _getToCenterPosition;
    zoomIn(position?: IPoint): void;
    zoomOut(position?: IPoint): void;
    private _onZoomToCenter;
    setZoom(position: IPoint, step: number, direction: EFZoomDirection, animated: boolean): void;
    getZoomValue(): number;
    reset(): void;
    private _disposeListeners;
    ngOnDestroy(): void;
    private _listen;
    private _unlisten;
    static ɵfac: i0.ɵɵFactoryDeclaration<FZoomDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FZoomDirective, "f-canvas[fZoom]", never, { "isEnabled": { "alias": "fZoom"; "required": false; "isSignal": true; }; "fWheelTrigger": { "alias": "fWheelTrigger"; "required": false; }; "fDblClickTrigger": { "alias": "fDblClickTrigger"; "required": false; }; "minimum": { "alias": "fZoomMinimum"; "required": false; }; "maximum": { "alias": "fZoomMaximum"; "required": false; }; "step": { "alias": "fZoomStep"; "required": false; }; "dblClickStep": { "alias": "fZoomDblClickStep"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_minimum: unknown;
    static ngAcceptInputType_maximum: unknown;
    static ngAcceptInputType_step: unknown;
    static ngAcceptInputType_dblClickStep: unknown;
}

declare const F_ZOOM_PROVIDERS: (typeof FZoomDirective)[];

declare abstract class FSelectionAreaBase implements IHasHostElement {
    readonly hostElement: any;
    abstract fTrigger: (event: FTriggerEvent) => boolean;
    protected initialize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FSelectionAreaBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FSelectionAreaBase, never, never, {}, {}, never, never, true, never>;
}

declare class FSelectionArea extends FSelectionAreaBase implements OnInit, OnDestroy {
    private readonly _mediator;
    fTrigger: FEventTrigger;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FSelectionArea, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FSelectionArea, "f-selection-area", never, { "fTrigger": { "alias": "fTrigger"; "required": false; }; }, {}, never, never, true, never>;
}

declare const F_SELECTION_AREA_PROVIDERS: (typeof FSelectionArea)[];

declare const F_MAGNETIC_LINES: InjectionToken<FMagneticLinesBase>;
declare abstract class FMagneticLinesBase {
    readonly hostElement: any;
    abstract threshold: Signal<number>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FMagneticLinesBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FMagneticLinesBase, never, never, {}, {}, never, never, true, never>;
}

declare class FMagneticLines extends FMagneticLinesBase implements OnInit, OnDestroy {
    readonly threshold: i0.InputSignalWithTransform<number, unknown>;
    private readonly _mediator;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FMagneticLines, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FMagneticLines, "f-magnetic-lines", never, { "threshold": { "alias": "threshold"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const F_MAGNETIC_LINES_PROVIDERS: (typeof FMagneticLines)[];

declare const F_MAGNETIC_RECTS: InjectionToken<FMagneticRectsBase>;
declare abstract class FMagneticRectsBase {
    readonly hostElement: any;
    abstract alignThreshold: Signal<number>;
    abstract spacingThreshold: Signal<number>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FMagneticRectsBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FMagneticRectsBase, never, never, {}, {}, never, never, true, never>;
}

declare class FMagneticRects extends FMagneticRectsBase implements OnInit, OnDestroy {
    readonly alignThreshold: i0.InputSignalWithTransform<number, unknown>;
    readonly spacingThreshold: i0.InputSignalWithTransform<number, unknown>;
    private readonly _mediator;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FMagneticRects, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FMagneticRects, "f-magnetic-rects", never, { "alignThreshold": { "alias": "alignThreshold"; "required": false; "isSignal": true; }; "spacingThreshold": { "alias": "spacingThreshold"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const F_MAGNETIC_RECTS_PROVIDERS: (typeof FMagneticRects)[];

declare class FMinimapFlowDirective {
    readonly fMinSize: i0.InputSignal<number>;
    private readonly _mediator;
    readonly hostElement: any;
    model: FMinimapState;
    redraw(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapFlowDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapFlowDirective, "svg[fMinimapFlow]", never, { "fMinSize": { "alias": "fMinSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FMinimapCanvasDirective {
    private readonly _mediator;
    private readonly _elementRef;
    readonly hostElement: any;
    redraw(): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapCanvasDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapCanvasDirective, "g[fMinimapCanvas]", never, {}, {}, never, never, true, never>;
}

declare class FMinimapViewDirective {
    private readonly _mediator;
    readonly hostElement: any;
    redraw(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapViewDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapViewDirective, "rect[fMinimapView]", never, {}, {}, never, never, true, never>;
}

declare const F_MINIMAP_BASE: InjectionToken<FMinimapBase>;
declare abstract class FMinimapBase {
    readonly hostElement: any;
    abstract state: FMinimapState;
    static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapBase, never, never, {}, {}, never, never, true, never>;
}

declare class FMinimapComponent extends FMinimapBase implements AfterViewInit, OnInit, OnDestroy {
    private readonly _destroyRef;
    private readonly _mediator;
    private readonly _browser;
    private readonly _store;
    readonly _canvas: i0.Signal<FMinimapCanvasDirective>;
    readonly _flow: i0.Signal<FMinimapFlowDirective>;
    readonly _minimapView: i0.Signal<FMinimapViewDirective>;
    readonly fMinSize: i0.InputSignal<number>;
    readonly fNodeRenderLimit: i0.InputSignalWithTransform<number, unknown>;
    get state(): _foblex_flow.FMinimapState;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private _listenTransformChanges;
    private _redraw;
    private _isOverNodeRenderLimit;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FMinimapComponent, "f-minimap", ["fComponent"], { "fMinSize": { "alias": "fMinSize"; "required": false; "isSignal": true; }; "fNodeRenderLimit": { "alias": "fNodeRenderLimit"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const F_MINIMAP_PROVIDERS: (typeof FMinimapFlowDirective | typeof FMinimapCanvasDirective | typeof FMinimapViewDirective | typeof FMinimapComponent)[];

declare class FComponentsStore {
    readonly transformChanges$: FChannel;
    readonly viewportAnimationChanges$: FChannel;
    readonly connectionsChanges$: FChannel;
    private _connectionsRevision;
    readonly connectionsRenderedChanges$: FChannel;
    private _connectionsRenderedRevision;
    private _connectionsRenderedNodesRevision;
    private _viewportAnimationCount;
    readonly nodesChanges$: FChannel;
    private _nodesRevision;
    readonly progressiveRenderChanges$: FChannel;
    private _pendingProgressiveRenderCount;
    get connectionsRevision(): number;
    get connectionsRenderedRevision(): number;
    get connectionsRenderedNodesRevision(): number;
    get nodesRevision(): number;
    get hasPendingProgressiveRender(): boolean;
    get isViewportAnimating(): boolean;
    get flowHost(): HTMLElement;
    fFlow: FFlowBase | undefined;
    fCanvas: FCanvasBase | undefined;
    get transform(): ITransformModel;
    readonly nodes: FNodeRegistry;
    readonly connections: FConnectionRegistry;
    readonly connectionMarkers: FConnectionMarkerRegistry;
    readonly outputs: FConnectorRegistry<FNodeOutputBase>;
    readonly inputs: FConnectorRegistry<FNodeInputBase>;
    readonly outlets: FConnectorRegistry<FNodeOutletBase>;
    readonly instances: FSingleRegistryBase;
    fDraggable: FDraggableBase | undefined;
    emitNodeChanges(): void;
    emitConnectionChanges(): void;
    completeConnectionsRender(revision: number, nodesRevision: number): void;
    beginProgressiveRender(): void;
    endProgressiveRender(): void;
    transformChanged(): void;
    beginViewportAnimation(): void;
    endViewportAnimation(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FComponentsStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FComponentsStore>;
}
declare const INSTANCES: {
    readonly MAGNETIC_LINES: _foblex_flow.FInstanceKey<FMagneticLinesBase>;
    readonly MAGNETIC_RECTS: _foblex_flow.FInstanceKey<FMagneticRectsBase>;
    readonly ZOOM: _foblex_flow.FInstanceKey<FZoomBase>;
    readonly BACKGROUND: _foblex_flow.FInstanceKey<FBackgroundBase>;
    readonly SELECTION_AREA: _foblex_flow.FInstanceKey<FSelectionAreaBase>;
    readonly MINIMAP: _foblex_flow.FInstanceKey<FMinimapBase>;
    readonly AUTO_PAN: _foblex_flow.FInstanceKey<FAutoPanBase>;
};

declare const F_STORAGE_PROVIDERS: (typeof FComponentsStore | typeof ListenConnectionsChanges | typeof ListenNodesChanges | typeof ListenTransformChanges | typeof EmitConnectionsChanges | typeof NotifyTransformChanged | typeof RegisterPluginInstance | typeof RemovePluginInstance)[];

declare class FLayoutController {
    private readonly _destroyRef;
    private readonly _flows;
    private _engine?;
    constructor();
    attachEngine(engine: FLayoutEngine): void;
    registerFlow(flow: FFlowBase, store: FComponentsStore): void;
    unregisterFlow(flowId: string): void;
    handleModeChanged(mode: EFLayoutMode): void;
    relayout(flowId?: string): Promise<void>;
    private _handleNodesChanges;
    private _handleConnectionsChanges;
    private _scheduleRelayout;
    private _relayoutFlowIfReady;
    private _relayoutRegisteredFlow;
    private _emitWriteback;
    private _applyPositions;
    private _buildNodeSignature;
    private _buildConnectionSignature;
    private _runAfterNextPaint;
    private _clearScheduledWork;
    private _cancelAnimationFrames;
    static ɵfac: i0.ɵɵFactoryDeclaration<FLayoutController, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FLayoutController>;
}

interface IFlowLayoutNormalizationResult extends IFLayoutGraph {
    nodeIds: Set<string>;
    groupIds: Set<string>;
}
declare function normalizeFlowLayoutData(state: IFFlowState): IFlowLayoutNormalizationResult;

declare function provideFLayout<TOptions extends IFLayoutOptions<string>, T extends FLayoutEngine<TOptions>>(engineType: Type<T>, config?: IFLayoutProviderConfig<TOptions>): Provider[];

/**
 * Strategy for selecting which nodes are shifted when a node resizes.
 *
 * - `CENTER_OF_MASS` — every node whose geometric center lies beyond the
 *   resizing node's center along the resize axis is a candidate. Simplest,
 *   global default.
 * - `X_RANGE` — like `CENTER_OF_MASS`, but narrowed to nodes whose
 *   perpendicular span overlaps the resizing node. Useful for column-style
 *   layouts.
 * - `DOWNSTREAM_CONNECTIONS` — only nodes reachable via outgoing connections
 *   are candidates; geometric filter applies on top. Cycles are detected.
 */
declare enum EFReflowMode {
    CENTER_OF_MASS = "center-of-mass",
    X_RANGE = "x-range",
    DOWNSTREAM_CONNECTIONS = "downstream-connections"
}

/**
 * Behavior when a candidate node would collide with a non-candidate during shift.
 *
 * - `STOP` — shift stops at the first collision, respecting the configured gap.
 *   Remaining delta is discarded.
 * - `CHAIN_PUSH` — the colliding non-candidate is absorbed into the plan and
 *   recursively pushed. Bounded by `maxCascadeDepth`.
 */
declare enum EFReflowCollision {
    STOP = "stop",
    CHAIN_PUSH = "chain-push"
}

/**
 * Which subset of the graph participates in a reflow plan.
 *
 * - `GLOBAL` — every node and group on the canvas.
 * - `GROUP` — only siblings sharing the resizing node's `fParentId`.
 * - `CONNECTED_SUBGRAPH` — only nodes in the same connected component
 *   (BFS over connections in both directions).
 */
declare enum EFReflowScope {
    GLOBAL = "global",
    GROUP = "group",
    CONNECTED_SUBGRAPH = "connected-subgraph"
}

/**
 * Axes along which reflow responds to a resize.
 *
 * When `BOTH`, the planner runs the vertical and horizontal passes
 * independently against the same baseline; the axis-order of application
 * is therefore commutative.
 */
declare enum EFReflowAxis {
    VERTICAL = "vertical",
    HORIZONTAL = "horizontal",
    BOTH = "both"
}

/**
 * How the delta between baseline and next rect is interpreted when shifting candidates.
 *
 * - `EDGE_BASED` (recommended) — the edge that actually moved drives the shift:
 *   nodes below the resizing node follow the bottom edge delta, nodes above
 *   follow the top edge delta. Correct under asymmetric resize (top-handle,
 *   bottom-handle, corner handles).
 * - `CENTER_BASED` — the whole delta is applied to candidates selected by
 *   center-line comparison. Simpler, but can misshift under asymmetric resize.
 */
declare enum EFReflowDeltaSource {
    EDGE_BASED = "edge-based",
    CENTER_BASED = "center-based"
}

interface IFReflowSpacingConfig {
    vertical?: number;
    horizontal?: number;
}
interface IFReflowOnResizeConfig {
    enabled?: boolean;
    mode?: EFReflowMode;
    collision?: EFReflowCollision;
    scope?: EFReflowScope;
    axis?: EFReflowAxis;
    deltaSource?: EFReflowDeltaSource;
    spacing?: IFReflowSpacingConfig;
    maxCascadeDepth?: number;
    maxAbsoluteShiftPerPlan?: number;
}
/**
 * Fully resolved, non-optional configuration. Consumers inside the feature
 * read from this shape after `mergeReflowConfig` fills in defaults.
 */
interface IFReflowOnResizeResolvedConfig {
    enabled: boolean;
    mode: EFReflowMode;
    collision: EFReflowCollision;
    scope: EFReflowScope;
    axis: EFReflowAxis;
    deltaSource: EFReflowDeltaSource;
    spacing: {
        vertical: number;
        horizontal: number;
    };
    maxCascadeDepth: number;
    maxAbsoluteShiftPerPlan: number;
}
declare const F_REFLOW_CONFIG: InjectionToken<IFReflowOnResizeResolvedConfig>;
declare function mergeReflowConfig(partial: IFReflowOnResizeConfig | undefined): IFReflowOnResizeResolvedConfig;

/**
 * A single node/group position change as computed by the planner.
 *
 * `fromRect` — rect of the candidate before the plan (canvas units).
 * `toRect`   — rect of the candidate after the plan (canvas units).
 *
 * Animators interpolate `fromRect` → `toRect`; synchronous writers apply `toRect` directly.
 */
interface IReflowShift {
    id: string;
    fromRect: IRect;
    toRect: IRect;
    toPosition: IPoint;
}
/**
 * Output of the planner for a single resize event.
 *
 * `sourceNodeId` — the node that was resized.
 * `shifts`       — zero or more candidate shifts. Empty list means no-op.
 * `deltaEdges`   — per-edge deltas of the resize (canvas units). For
 *   `EDGE_BASED` delta-source these drive candidate shifts directly.
 */
interface IReflowPlan {
    sourceNodeId: string;
    shifts: IReflowShift[];
    deltaEdges: {
        top: number;
        right: number;
        bottom: number;
        left: number;
    };
}
declare const EMPTY_REFLOW_PLAN: (sourceNodeId: string) => IReflowPlan;

/**
 * Per-edge deltas produced by a resize.
 *
 * All values are signed:
 * - positive `top` or `left` = the edge moved outward (grow from that side)
 * - positive `bottom` or `right` = the edge moved outward in the same direction
 * - the sum along an axis equals the total size change on that axis.
 */
interface IResizeEdgeDeltas {
    top: number;
    right: number;
    bottom: number;
    left: number;
}
declare function computeEdgeDeltas(baseline: IRect, next: IRect): IResizeEdgeDeltas;
/**
 * Computes the raw shift vector a candidate should receive for a single resize
 * event, before collision/scope adjustments.
 *
 * Returns `null` when the candidate is not affected on the active axis.
 */
interface IFReflowDeltaCalculator {
    calculate(input: {
        baselineRect: IRect;
        nextRect: IRect;
        candidateRect: IRect;
        axis: EFReflowAxis;
    }): IPoint | null;
}

/**
 * Computes shift vectors based on which edges of the resized node moved and
 * whether the candidate lies beyond that edge in the pre-resize layout.
 *
 * Rules (vertical axis):
 * - `deltaEdges.bottom > 0` (bottom grew outward) and `candidate.top >= baseline.bottom`
 *   → candidate shifts down by `deltaEdges.bottom`.
 * - `deltaEdges.bottom < 0` (bottom collapsed upward) and `candidate.top >= nextBottom`
 *   → candidate shifts up by `deltaEdges.bottom`.
 * - `deltaEdges.top > 0` (top grew outward, i.e. node expanded upward) and
 *   `candidate.bottom <= baseline.top` → candidate shifts up by `-deltaEdges.top`.
 * - `deltaEdges.top < 0` (top collapsed downward) and `candidate.bottom <= nextTop`
 *   → candidate shifts down by `-deltaEdges.top`.
 *
 * Horizontal axis is symmetric (swap top/bottom with left/right).
 */
declare class EdgeBasedDeltaCalculator implements IFReflowDeltaCalculator {
    calculate({ baselineRect, nextRect, candidateRect, axis, }: {
        baselineRect: IRect;
        nextRect: IRect;
        candidateRect: IRect;
        axis: EFReflowAxis;
    }): IPoint | null;
    private _verticalShift;
    private _horizontalShift;
}

/**
 * Roadmap-formula variant: shifts whole scalar delta based on center-line comparison.
 *
 * Vertical:
 *   deltaHeight = nextRect.height - baselineRect.height
 *   if deltaHeight !== 0 AND candidate.centerY > baseline.centerY → shift by deltaHeight
 *
 * This path has a known edge case under asymmetric resize (top-handle vs
 * bottom-handle), where a node's center moves by `deltaHeight/2` but the full
 * `deltaHeight` is applied to candidates — leading to mis-shifts when the top
 * edge is the one that actually moved. The edge-based calculator is preferred
 * for correctness; this implementation matches the formula as written in the
 * technical roadmap for users who opt in explicitly.
 */
declare class CenterBasedDeltaCalculator implements IFReflowDeltaCalculator {
    calculate({ baselineRect, nextRect, candidateRect, axis, }: {
        baselineRect: IRect;
        nextRect: IRect;
        candidateRect: IRect;
        axis: EFReflowAxis;
    }): IPoint | null;
    private _verticalShift;
    private _horizontalShift;
}

/**
 * A node entry visible to the reflow planner. Produced by the orchestrator
 * from `FComponentsStore` + `GetNormalizedElementRectRequest`.
 */
interface IReflowCandidate {
    id: string;
    rect: IRect;
    parentId: string | null | undefined;
    isIgnored: boolean;
}
/**
 * Node-to-node link materialised from `FComponentsStore.connections` by
 * the orchestrator. Connector ids are resolved up to owning node ids so
 * graph-based selection strategies don't need to walk the connector
 * registry themselves.
 */
interface IReflowConnection {
    outputNodeId: string;
    inputNodeId: string;
}
/**
 * Pre-filter that narrows the candidate pool by mode (geometric / graph-based).
 * Does not apply deltas or scope constraints.
 */
interface IFReflowSelectionStrategy {
    select(input: {
        sourceId: string;
        sourceBaselineRect: IRect;
        sourceNextRect: IRect;
        candidates: IReflowCandidate[];
        connections: IReflowConnection[];
        axis: EFReflowAxis;
    }): IReflowCandidate[];
}

/**
 * Default strategy: every candidate except the source and ignored nodes is
 * eligible. The actual "who is actually below / above" decision is made by
 * the delta calculator based on geometric comparison of rects.
 */
declare class CenterOfMassSelectionStrategy implements IFReflowSelectionStrategy {
    select({ sourceId, candidates, }: {
        sourceId: string;
        candidates: IReflowCandidate[];
    }): IReflowCandidate[];
}

/**
 * Restricts the candidate pool to nodes that overlap the resizing source
 * on the *perpendicular* axis:
 *
 * - Vertical resize → keep candidates whose horizontal span intersects
 *   the source (`[M.left, M.right] ∩ [N.left, N.right] ≠ ∅`).
 * - Horizontal resize → keep candidates whose vertical span intersects
 *   the source.
 * - Combined (`BOTH`) → keep candidates that overlap on either axis.
 *
 * Compared to `CENTER_OF_MASS`, this localises the reflow to the same
 * visual column / row as the source — useful for column-style workflows
 * where global shifts are too aggressive.
 */
declare class XRangeSelectionStrategy implements IFReflowSelectionStrategy {
    select({ sourceId, sourceBaselineRect, sourceNextRect, candidates, axis, }: {
        sourceId: string;
        sourceBaselineRect: IRect;
        sourceNextRect: IRect;
        candidates: IReflowCandidate[];
        axis: EFReflowAxis;
    }): IReflowCandidate[];
    private _overlapsX;
    private _overlapsY;
}

/**
 * Restricts the candidate pool to nodes reachable from the source via
 * outgoing connections (BFS).
 *
 * - Walks `outputNodeId === sourceId → inputNodeId` repeatedly.
 * - Cycles (legitimate or adversarial) terminate via `FReflowCycleGuard`.
 * - The geometric "is this candidate actually below / right of the
 *   source" decision still happens later in the delta calculator —
 *   this strategy only narrows the pool to graph-downstream nodes.
 *
 * Practical use: workflow editors where the user expects a resize to
 * cascade only along the data flow, not to unrelated branches.
 */
declare class DownstreamConnectionsSelectionStrategy implements IFReflowSelectionStrategy {
    private readonly _maxCascadeDepth;
    constructor(_maxCascadeDepth: number);
    select({ sourceId, candidates, connections, }: {
        sourceId: string;
        candidates: IReflowCandidate[];
        connections: IReflowConnection[];
    }): IReflowCandidate[];
    private _buildAdjacency;
}

/**
 * Bounded visited-set guard for graph traversals.
 *
 * BFS / DFS over the connection graph must terminate even when the user
 * has authored cycles (which f-flow allows). The guard rejects already-
 * visited node ids and trips a depth fuse when traversal exceeds the
 * configured ceiling — defending against adversarial graph shapes
 * without imposing a static depth limit on legitimate ones.
 */
declare class FReflowCycleGuard {
    private readonly _maxDepth;
    private readonly _visited;
    constructor(_maxDepth: number);
    visit(id: string): boolean;
    has(id: string): boolean;
    size(): number;
}

/**
 * Narrows the pool further by scope (global / group / connected-subgraph).
 *
 * Applied after the selection strategy so that scope is always an intersection,
 * never a union.
 */
interface IFReflowScopeFilter {
    filter(input: {
        sourceCandidate: IReflowCandidate | null;
        candidates: IReflowCandidate[];
        connections: IReflowConnection[];
    }): IReflowCandidate[];
}

declare class GlobalScopeFilter implements IFReflowScopeFilter {
    filter({ candidates }: {
        candidates: IReflowCandidate[];
    }): IReflowCandidate[];
}

/**
 * Restricts the candidate pool to siblings of the resizing source —
 * candidates whose `fParentId` matches the source's. With no source
 * candidate or a top-level source (`parentId == null`), only top-level
 * candidates pass.
 *
 * Use case: a node inside a group expands; we want neighbors *inside the
 * same group* to shift, but not nodes living outside the group's
 * boundary or under a different parent.
 */
declare class GroupScopeFilter implements IFReflowScopeFilter {
    filter({ sourceCandidate, candidates, }: {
        sourceCandidate: IReflowCandidate | null;
        candidates: IReflowCandidate[];
    }): IReflowCandidate[];
}

/**
 * Restricts the candidate pool to nodes in the same connected component
 * as the resizing source — BFS over connections in *both* directions.
 *
 * Compared to `DOWNSTREAM_CONNECTIONS` selection (one-directional), this
 * scope keeps upstream nodes too. Useful when a graph has multiple
 * disconnected sub-flows on the same canvas and a resize should affect
 * only its own component.
 */
declare class ConnectedSubgraphScopeFilter implements IFReflowScopeFilter {
    filter({ sourceCandidate, candidates, connections, }: {
        sourceCandidate: IReflowCandidate | null;
        candidates: IReflowCandidate[];
        connections: IReflowConnection[];
    }): IReflowCandidate[];
    private _buildBidirectionalAdjacency;
    private _bfs;
}

interface IReflowRawShift {
    candidate: IReflowCandidate;
    shift: IPoint;
}
interface IReflowResolvedShift {
    candidate: IReflowCandidate;
    fromRect: IRect;
    toRect: IRect;
    toPosition: IPoint;
}
interface IFReflowCollisionResolver {
    resolve(input: {
        sourceNextRect: IRect;
        rawShifts: IReflowRawShift[];
        pool: IReflowCandidate[];
        spacing: {
            vertical: number;
            horizontal: number;
        };
        maxAbsoluteShift: number;
    }): IReflowResolvedShift[];
}

/**
 * STOP collision: a candidate shifts in its requested direction up to the
 * point where its post-shift rect would violate the configured spacing
 * against any non-shifting obstacle. Remaining delta is discarded.
 *
 * Obstacles considered:
 * - The resized node at its `nextRect`.
 * - Every pool member that is not itself shifting on this plan.
 *
 * Obstacles only block on axes where the candidate and obstacle share
 * perpendicular overlap — nodes side-by-side do not block each other on
 * the vertical axis, and nodes stacked vertically do not block on the
 * horizontal axis.
 */
declare class StopCollisionResolver implements IFReflowCollisionResolver {
    resolve({ sourceNextRect, rawShifts, pool, spacing, maxAbsoluteShift, }: {
        sourceNextRect: IRect;
        rawShifts: IReflowRawShift[];
        pool: IReflowCandidate[];
        spacing: {
            vertical: number;
            horizontal: number;
        };
        maxAbsoluteShift: number;
    }): IReflowResolvedShift[];
    private _clampVerticalShift;
    private _clampHorizontalShift;
    private _overlapsOnX;
    private _overlapsOnY;
    private _clampAbs;
}

/**
 * CHAIN_PUSH collision: when a shifting candidate would collide with a
 * non-shifting pool member, the colliding node is *included* in the
 * plan and pushed away by enough to restore spacing — instead of
 * clamping the original shift like `STOP` would.
 *
 * The pushed node may itself now collide with further pool members; the
 * process iterates until the plan stabilises or `maxCascadeDepth` is
 * exceeded. All work happens in a single `resolve()` call — the planner
 * is not re-invoked, so the result remains stateless.
 *
 * Versus STOP:
 * - STOP preserves the original layout outside the shift pool; remainder
 *   delta is lost when a candidate hits an obstacle.
 * - CHAIN_PUSH treats the obstacle as a domino and absorbs it into the
 *   shift, producing a tighter layout at the cost of touching more nodes.
 */
declare class ChainPushCollisionResolver implements IFReflowCollisionResolver {
    private readonly _maxCascadeDepth;
    constructor(_maxCascadeDepth: number);
    resolve({ rawShifts, pool, spacing, maxAbsoluteShift, }: {
        sourceNextRect: IRect;
        rawShifts: IReflowRawShift[];
        pool: IReflowCandidate[];
        spacing: {
            vertical: number;
            horizontal: number;
        };
        maxAbsoluteShift: number;
    }): IReflowResolvedShift[];
    /**
     * If `mover` (already shifted) overlaps `target` (stationary) below
     * the configured per-axis spacing, return the displacement that would
     * restore that spacing. The push direction is determined by which
     * edge of the mover is impinging on the target.
     */
    private _computePush;
    private _shifted;
    private _overlapsX;
    private _overlapsY;
    private _clampAbs;
}

interface IReflowPlannerInput {
    sourceId: string;
    baselineRect: IRect;
    nextRect: IRect;
    candidates: IReflowCandidate[];
    connections: IReflowConnection[];
    config: IFReflowOnResizeResolvedConfig;
}
/**
 * Pure planner: no DI, no side effects. Consumes rect data + config and
 * produces a plan the orchestrator/animator can apply.
 *
 * Phase 1 coverage: `CENTER_OF_MASS` selection, `GLOBAL` scope, `STOP`
 * collision. Unsupported modes fall back to no-op until subsequent phases
 * add their strategies.
 */
declare class FReflowPlanner {
    private readonly _edgeBased;
    private readonly _centerBased;
    private readonly _centerOfMassSelection;
    private readonly _xRangeSelection;
    private readonly _globalScope;
    private readonly _groupScope;
    private readonly _connectedSubgraphScope;
    private readonly _stopCollision;
    plan(input: IReflowPlannerInput): IReflowPlan;
    /**
     * Clamps each candidate's shift so the post-shift rect cannot extend
     * past its parent's outer bounds. The parent's edges act as walls —
     * a shift that would carry a sibling outside the group is reduced to
     * land flush against the inside edge.
     *
     * Top-level candidates (no parent) pass through unchanged. Spacing is
     * intentionally not applied here: that is a between-nodes concern and
     * is handled by the collision resolver against fellow shifts. Adding
     * spacing here would also fight any candidate whose original position
     * is already on or past the parent's edge.
     */
    private _clampToParentBounds;
    /**
     * Returns candidates with the source itself, the source's full parent
     * chain, and the source's descendant subtree all removed. Cycle-safe
     * via visited sets so malformed parent links cannot loop forever.
     */
    private _excludeSourceAncestorsAndDescendants;
    /**
     * Reflow reacts to SIZE changes only. A pure translation (position
     * changed, size unchanged) must not generate shifts — doing so would
     * cascade through every candidate that was just shifted, since each
     * shift re-enters this path via `stateChanges.notify()` in
     * `FNodeDirective.refresh()`.
     */
    private _isNoOpDelta;
    private _resolveSelection;
    private _resolveScope;
    private _resolveCollision;
    private _resolveDeltaCalculator;
    private _computeRawShifts;
    static ɵfac: i0.ɵɵFactoryDeclaration<FReflowPlanner, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FReflowPlanner>;
}

/**
 * Drives the resize → plan → apply pipeline.
 *
 * Invoked from two places:
 * - `UpdateNodeWhenStateOrSizeChanged` for content-driven resize (expand /
 *   collapse / programmatic `[fNodeSize]`). The caller does not provide a
 *   baseline — the tracker supplies one.
 * - `ResizeNodeHandler.onPointerUp` for user drag-resize, which provides
 *   the pre-drag baseline captured in `prepareDragSequence`.
 *
 * Shifts apply synchronously through `position.set` — no animator.
 * Per-node DOM writes are gated by `hostElement.isConnected` so a plan
 * that arrives during consumer-side teardown (e.g. parent reset) cannot
 * push stale view models through Angular CD.
 */
declare class FReflowOrchestrator {
    private readonly _controller;
    private readonly _store;
    private readonly _mediator;
    private readonly _ignoreRegistry;
    private readonly _planner;
    private readonly _tracker;
    handleResize(sourceNode: FNodeBase, baselineRect?: IRect): void;
    private _buildCandidates;
    /**
     * Resolves f-flow's connector-keyed connections down to node-to-node
     * links so graph-based selection strategies (DOWNSTREAM) can BFS
     * without walking the connector registry themselves.
     */
    private _buildConnections;
    private _safeGetRect;
    static ɵfac: i0.ɵɵFactoryDeclaration<FReflowOrchestrator, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FReflowOrchestrator>;
}

/**
 * Feature-local registry of node/group ids flagged with `fReflowIgnore`.
 *
 * The directive registers its host id on attach and removes it on detach;
 * the orchestrator queries the set when building the candidate pool.
 *
 * Kept separate from `FNodeBase` so activating the reflow feature never
 * forces a structural change on the core node API.
 */
declare class FReflowIgnoreRegistry {
    private readonly _ignored;
    add(id: string): void;
    remove(id: string): void;
    has(id: string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<FReflowIgnoreRegistry, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FReflowIgnoreRegistry>;
}

/**
 * Anchors the host `<f-node>` / `<f-group>` in place during reflow.
 * The node never receives a primary shift even if mode and scope would
 * otherwise pick it as a candidate, but it stays visible to the
 * collision resolver so:
 *
 * - **STOP** clamps neighbouring shifts against this anchor.
 * - **CHAIN_PUSH** treats the anchor as an obstacle to push past — the
 *   cascade can still absorb it if a primary shift physically collides
 *   with it.
 *
 * ```html
 * <div fNode fReflowIgnore>sticky annotation</div>
 * ```
 *
 * Reads as a boolean attribute; ignored when the reflow feature is not
 * registered (the registry is an optional inject).
 */
declare class FReflowIgnore implements OnInit, OnDestroy {
    readonly fReflowIgnore: i0.InputSignalWithTransform<boolean, unknown>;
    private readonly _registry;
    private readonly _node;
    private readonly _injector;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FReflowIgnore, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FReflowIgnore, "[fReflowIgnore]", never, { "fReflowIgnore": { "alias": "fReflowIgnore"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Public runtime API for the reflow-on-resize feature.
 *
 * Always instantiated at the `<f-flow>` injector level — regardless of
 * whether `withReflowOnResize(...)` was registered. The feature is inert
 * until `F_REFLOW_CONFIG` becomes available through the optional inject;
 * without it, `isEnabled` is `false` and the orchestrator short-circuits.
 *
 * ```typescript
 * const reflow = inject(FReflowController);
 * reflow.setConfig({ spacing: { vertical: 24 } });
 * ```
 */
declare class FReflowController {
    private readonly _initial;
    private readonly _featureActivated;
    private readonly _config;
    readonly config: Signal<IFReflowOnResizeResolvedConfig>;
    readonly isEnabled: Signal<boolean>;
    getConfig(): IFReflowOnResizeResolvedConfig;
    setConfig(partial: IFReflowOnResizeConfig): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FReflowController, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FReflowController>;
}

/**
 * Per-node "last known rect" used to derive the baseline for the next resize.
 *
 * Independent from `FCache` so reflow works even when the cache feature is
 * disabled (its default state). Populated on every orchestrator invocation:
 * the first observation of a node has no baseline yet and produces no plan
 * — subsequent observations diff against the recorded rect.
 *
 * Not part of serialization — purely transient UI state.
 */
declare class FReflowBaselineTracker {
    private readonly _baselines;
    get(id: string): IRect | undefined;
    set(id: string, rect: IRect): void;
    delete(id: string): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FReflowBaselineTracker, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FReflowBaselineTracker>;
}

/**
 * Services that must live at the `<f-flow>` injector level because they
 * consume `FComponentsStore` and `FMediator` provided there.
 *
 * Wired unconditionally in `FFlowComponent.providers`. They stay inert
 * until `withReflowOnResize(...)` installs `F_REFLOW_CONFIG` further up
 * the injector tree — the orchestrator and friends reach the controller
 * (also installed by `withReflowOnResize`) through the parent chain.
 *
 * `FReflowController` is intentionally NOT in this list: it is provided
 * by `withReflowOnResize(...)` so consumers can `inject(FReflowController)`
 * directly from the same component that calls `provideFFlow(...)`.
 */
declare const F_REFLOW_PROVIDERS: (typeof FReflowOrchestrator | typeof FReflowIgnoreRegistry | typeof FReflowPlanner | typeof FReflowBaselineTracker)[];

/**
 * Activates the reflow-on-resize feature inside `provideFFlow(...)`.
 *
 * ```typescript
 * @Component({
 *   providers: [
 *     provideFFlow(
 *       withReflowOnResize({ mode: EFReflowMode.CENTER_OF_MASS }),
 *     ),
 *   ],
 * })
 * export class MyFlow {
 *   private readonly _reflow = inject(FReflowController);
 *   // ...
 * }
 * ```
 *
 * Installs `F_REFLOW_CONFIG` and `FReflowController` at the host
 * component's injector — both are reachable from the same component
 * that calls `provideFFlow(...)`. The downstream services
 * (`FReflowOrchestrator`, `FReflowPlanner`, `FReflowIgnoreRegistry`,
 * `FReflowBaselineTracker`) are provided unconditionally by `<f-flow>`
 * and find the controller via the parent injector chain.
 *
 * Registering the feature twice replaces the earlier config via Angular's
 * last-wins provider semantics.
 */
declare function withReflowOnResize(config?: IFReflowOnResizeConfig): IFFlowFeature<EFFlowFeatureKind.REFLOW_ON_RESIZE>;

/**
 * @deprecated Use `f-magnetic-lines` instead.
 * Will be removed in v19.0.0.
 */
declare class FLineAlignmentComponent extends FMagneticLinesBase implements OnInit, OnDestroy {
    readonly threshold: i0.InputSignalWithTransform<number, unknown>;
    private readonly _mediator;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FLineAlignmentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FLineAlignmentComponent, "f-line-alignment", ["fComponent"], { "threshold": { "alias": "fAlignThreshold"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
}

declare const F_LINE_ALIGNMENT_PROVIDERS: (typeof FLineAlignmentComponent)[];

interface ICacheOptions {
    enabled: boolean;
}
declare const F_CACHE_OPTIONS: InjectionToken<ICacheOptions>;
declare function fProvideCache(options?: Partial<ICacheOptions>): Provider;

declare class RegisterFCacheConnectorRequest {
    readonly id: string;
    readonly nodeId: string;
    readonly kind: string;
    readonly element: HTMLElement | SVGElement;
    static readonly fToken: unique symbol;
    constructor(id: string, nodeId: string, kind: string, element: HTMLElement | SVGElement);
}

declare class RegisterFCacheConnector implements IExecution<RegisterFCacheConnectorRequest, void> {
    private readonly _store;
    private readonly _mediator;
    private readonly _options;
    handle({ id, nodeId, kind, element }: RegisterFCacheConnectorRequest): void;
    private _detachConnectorFromNode;
    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterFCacheConnector, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RegisterFCacheConnector>;
}

declare class UnregisterFCacheConnectorRequest {
    readonly connectorId: string;
    readonly kind: string;
    static readonly fToken: unique symbol;
    constructor(connectorId: string, kind: string);
}

declare class UnregisterFCacheConnector implements IExecution<UnregisterFCacheConnectorRequest, void> {
    private readonly _store;
    private readonly _mediator;
    private readonly _options;
    handle({ connectorId, kind }: UnregisterFCacheConnectorRequest): void;
    private _detachConnectorFromNode;
    static ɵfac: i0.ɵɵFactoryDeclaration<UnregisterFCacheConnector, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UnregisterFCacheConnector>;
}

declare class InvalidateFCacheNodeRequest {
    readonly nodeId: string;
    readonly reason: string;
    static readonly fToken: unique symbol;
    constructor(nodeId: string, reason?: string);
}

declare class InvalidateFCacheNode implements IExecution<InvalidateFCacheNodeRequest, void> {
    private readonly _store;
    private readonly _options;
    handle({ nodeId, reason: _reason }: InvalidateFCacheNodeRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InvalidateFCacheNode, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InvalidateFCacheNode>;
}

type FCacheConnectorKey = string;
declare class FCacheConnectorKeyFactory {
    static build(connectorId: string, kind: string): FCacheConnectorKey;
}

declare class FCacheConnector {
    readonly key: FCacheConnectorKey;
    readonly id: string;
    readonly kind: string;
    readonly nodeId: string;
    element: HTMLElement | SVGElement;
    rect?: (IRoundedRect | null) | undefined;
    constructor(key: FCacheConnectorKey, id: string, kind: string, nodeId: string, element: HTMLElement | SVGElement, rect?: (IRoundedRect | null) | undefined);
}

interface IFCacheNodeRef {
    _position: {
        x: number;
        y: number;
    };
}

declare class FCacheNode {
    readonly id: string;
    readonly element: HTMLElement | SVGElement;
    readonly reference: IFCacheNodeRef;
    rect?: (IRect | null) | undefined;
    constructor(id: string, element: HTMLElement | SVGElement, reference: IFCacheNodeRef, rect?: (IRect | null) | undefined);
}

declare class FCache {
    readonly nodeEntries: Map<string, FCacheNode>;
    readonly nodeIdByElement: WeakMap<Element, string>;
    readonly connectorEntries: Map<string, FCacheConnector>;
    readonly connectorKeysByNodeId: Map<string, Set<string>>;
    readonly connectorKeyByElement: WeakMap<Element, string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FCache, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FCache>;
}

declare class RegisterFCacheNodeRequest {
    readonly id: string;
    readonly element: HTMLElement | SVGElement;
    readonly reference: IFCacheNodeRef;
    static readonly fToken: unique symbol;
    constructor(id: string, element: HTMLElement | SVGElement, reference: IFCacheNodeRef);
}

declare class RegisterFCacheNode implements IExecution<RegisterFCacheNodeRequest, void> {
    private readonly _store;
    private readonly _options;
    handle({ id, element, reference }: RegisterFCacheNodeRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RegisterFCacheNode, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RegisterFCacheNode>;
}

declare class UnregisterFCacheNodeRequest {
    readonly id: string;
    static readonly fToken: unique symbol;
    constructor(id: string);
}

declare class UnregisterFCacheNode implements IExecution<UnregisterFCacheNodeRequest, void> {
    private readonly _store;
    private readonly _mediator;
    private readonly _options;
    handle({ id }: UnregisterFCacheNodeRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UnregisterFCacheNode, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UnregisterFCacheNode>;
}

declare class GetCachedFCacheRectRequest {
    readonly element: HTMLElement | SVGElement;
    static readonly fToken: unique symbol;
    constructor(element: HTMLElement | SVGElement);
}

declare class GetCachedFCacheRect implements IExecution<GetCachedFCacheRectRequest, IRect | undefined> {
    private readonly _store;
    private readonly _options;
    handle({ element }: GetCachedFCacheRectRequest): IRect | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetCachedFCacheRect, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GetCachedFCacheRect>;
}

declare class SetFCacheConnectorRectRequest {
    readonly connectorId: string;
    readonly kind: string;
    readonly rect: IRoundedRect;
    static readonly fToken: unique symbol;
    constructor(connectorId: string, kind: string, rect: IRoundedRect);
}

declare class SetFCacheConnectorRect implements IExecution<SetFCacheConnectorRectRequest, void> {
    private readonly _store;
    private readonly _options;
    handle({ connectorId, kind, rect }: SetFCacheConnectorRectRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SetFCacheConnectorRect, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SetFCacheConnectorRect>;
}

declare class SetFCacheNodeRectRequest {
    readonly nodeId: string;
    readonly rect: IRect;
    static readonly fToken: unique symbol;
    constructor(nodeId: string, rect: IRect);
}

declare class SetFCacheNodeRect implements IExecution<SetFCacheNodeRectRequest, void> {
    private readonly _store;
    private readonly _options;
    handle({ nodeId, rect }: SetFCacheNodeRectRequest): void;
    private _updateConnectorRectsByNodeRect;
    static ɵfac: i0.ɵɵFactoryDeclaration<SetFCacheNodeRect, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SetFCacheNodeRect>;
}

declare class UpdateFCacheRectByElementRequest {
    readonly element: HTMLElement | SVGElement;
    readonly rect: IRect | IRoundedRect;
    static readonly fToken: unique symbol;
    constructor(element: HTMLElement | SVGElement, rect: IRect | IRoundedRect);
}

declare class UpdateFCacheRectByElement implements IExecution<UpdateFCacheRectByElementRequest, void> {
    private readonly _store;
    private readonly _options;
    handle({ element, rect }: UpdateFCacheRectByElementRequest): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateFCacheRectByElement, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UpdateFCacheRectByElement>;
}

declare const F_CACHE_FEATURES: (typeof FCache | typeof InvalidateFCacheNode | typeof RegisterFCacheNode | typeof UnregisterFCacheNode | typeof RegisterFCacheConnector | typeof UnregisterFCacheConnector | typeof GetCachedFCacheRect | typeof SetFCacheConnectorRect | typeof SetFCacheNodeRect | typeof UpdateFCacheRectByElement)[];

declare class FVirtualFor<T> implements OnChanges, OnDestroy {
    fVirtualForOf: readonly T[];
    private readonly _vc;
    private readonly _tpl;
    private readonly _zone;
    private readonly _componentsStore;
    private _rafId;
    private _isProgressiveRenderActive;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private _reset;
    private _renderProgressively;
    private _insertView;
    private _startProgressiveRender;
    private _finishProgressiveRender;
    static ɵfac: i0.ɵɵFactoryDeclaration<FVirtualFor<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FVirtualFor<any>, "[fVirtualFor][fVirtualForOf]", never, { "fVirtualForOf": { "alias": "fVirtualForOf"; "required": false; }; }, {}, never, never, true, never>;
}

declare const F_VIRTUAL_FOR_PROVIDERS: (typeof FVirtualFor)[];

declare function calculatePointerInFlow(position: IPoint, flowHost: HTMLElement, transform: ITransformModel): Point;

declare function infinityMinMax(): IMinMaxPoint;

declare function stringAttribute(value: unknown): string | undefined;

declare class FFlowModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FFlowModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FFlowModule, [typeof FConnectionDragHandleStart, typeof FConnectionDragHandleEnd, typeof FConnectionPath, typeof FConnectionSelection, typeof FConnectionMarker, typeof FConnectionComponent, typeof FConnectionForCreateComponent, typeof FSnapConnectionComponent, typeof FNodeInputDirective, typeof FNodeOutletDirective, typeof FNodeOutputDirective, typeof FLineAlignmentComponent, typeof FGroupDirective, typeof FNodeDirective, typeof FDragHandleDirective, typeof FResizeHandleDirective, typeof FRotateHandleDirective, typeof FDragBlockerDirective, typeof FDraggableDirective], [typeof FFlowComponent, typeof FCanvasComponent, typeof FBackgroundComponent, typeof FRectPatternComponent, typeof FCirclePatternComponent, typeof FAutoPan, typeof FZoomDirective, typeof FExternalItem, typeof FMinimapComponent, typeof FMinimapCanvasDirective, typeof FMinimapViewDirective, typeof FMinimapFlowDirective, typeof FSelectionArea, typeof FMagneticLines, typeof FMagneticRects, typeof FConnectionContent, typeof FConnectionMarkerCircle, typeof FConnectionMarkerArrow, typeof FConnectionGradient, typeof FConnectionGradientRenderer, typeof FConnectionWaypoints, typeof FVirtualFor, typeof FReflowIgnore, typeof i43.CommonModule], [typeof FFlowComponent, typeof FCanvasComponent, typeof FBackgroundComponent, typeof FRectPatternComponent, typeof FCirclePatternComponent, typeof FAutoPan, typeof FZoomDirective, typeof FExternalItem, typeof FSelectionArea, typeof FMagneticLines, typeof FMagneticRects, typeof FConnectionContent, typeof FConnectionMarkerCircle, typeof FConnectionMarkerArrow, typeof FConnectionGradient, typeof FConnectionGradientRenderer, typeof FConnectionWaypoints, typeof FConnectionDragHandleStart, typeof FConnectionDragHandleEnd, typeof FConnectionPath, typeof FConnectionSelection, typeof FConnectionMarker, typeof FConnectionComponent, typeof FConnectionForCreateComponent, typeof FSnapConnectionComponent, typeof FNodeInputDirective, typeof FNodeOutletDirective, typeof FNodeOutputDirective, typeof FLineAlignmentComponent, typeof FMinimapComponent, typeof FMinimapCanvasDirective, typeof FMinimapViewDirective, typeof FMinimapFlowDirective, typeof FGroupDirective, typeof FNodeDirective, typeof FDragHandleDirective, typeof FResizeHandleDirective, typeof FRotateHandleDirective, typeof FVirtualFor, typeof FReflowIgnore, typeof FDragBlockerDirective, typeof FDraggableDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FFlowModule>;
}

export { AddCanvasToStore, AddCanvasToStoreRequest, AddConnectionForCreateToStore, AddConnectionForCreateToStoreRequest, AddConnectionMarkerToStore, AddConnectionMarkerToStoreRequest, AddConnectionToStore, AddConnectionToStoreRequest, AddConnectorToStore, AddConnectorToStoreRequest, AddDndToStore, AddDndToStoreRequest, AddFlowToStore, AddFlowToStoreRequest, AddNodeToStore, AddNodeToStoreRequest, AddPatternToBackground, AddPatternToBackgroundRequest, AddSnapConnectionToStore, AddSnapConnectionToStoreRequest, ApplyChildResizeConstraints, ApplyChildResizeConstraintsRequest, ApplyConnectionRender, ApplyConnectionRenderRequest, ApplyConnectionWorkerResult, ApplyConnectionWorkerResultRequest, ApplyParentResizeConstraints, ApplyParentResizeConstraintsRequest, AttachDragNodeHandlerFromSelection, AttachDragNodeHandlerFromSelectionRequest, AttachResizeConnectionDragHandlersToNode, AttachResizeConnectionDragHandlersToNodeRequest, AttachSoftParentConnectionDragHandlersToNode, AttachSoftParentConnectionDragHandlersToNodeRequest, AttachSourceConnectionDragHandlersToNode, AttachSourceConnectionDragHandlersToNodeRequest, AttachTargetConnectionDragHandlersToNode, AttachTargetConnectionDragHandlersToNodeRequest, BuildConnectionLine, BuildConnectionLineRequest, BuildConnectionWorkerBatch, BuildConnectionWorkerBatchRequest, BuildConnectionWorkerPayloadItem, BuildConnectionWorkerPayloadItemRequest, BuildDragNodeConstraints, BuildDragNodeConstraintsRequest, CALCULATABLE_SIDES, COMMON_PROVIDERS, CONNECTABLE_SIDE_EPSILON, CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS, CalculateAdaptiveCurveData, CalculateBezierCurveData, CalculateChangedRectFromDifference, CalculateChangedRectFromDifferenceRequest, CalculateClosestConnector, CalculateClosestConnectorRequest, CalculateConnectableSideByConnectedPositions, CalculateConnectableSideByConnectedPositionsRequest, CalculateConnectableSideByInternalPosition, CalculateConnectableSideByInternalPositionRequest, CalculateConnectionsState, CalculateConnectionsStateRequest, CalculateConnectorsConnectableSides, CalculateConnectorsConnectableSidesRequest, CalculateDirectChildrenUnionRect, CalculateDirectChildrenUnionRectRequest, CalculateFlowPointFromMinimapPoint, CalculateFlowPointFromMinimapPointRequest, CalculateFlowState, CalculateFlowStateRequest, CalculateInputConnections, CalculateInputConnectionsRequest, CalculateNodesBoundingBox, CalculateNodesBoundingBoxNormalizedPosition, CalculateNodesBoundingBoxNormalizedPositionRequest, CalculateNodesBoundingBoxRequest, CalculateNodesState, CalculateNodesStateRequest, CalculateOutputConnections, CalculateOutputConnectionsRequest, CalculateResizeLimits, CalculateResizeLimitsRequest, CalculateSegmentLineData, CalculateSelectableItems, CalculateSelectableItemsRequest, CalculateSourceConnectorsToConnect, CalculateSourceConnectorsToConnectRequest, CalculateStraightLineData, CalculateTargetConnectorsToConnect, CalculateTargetConnectorsToConnectRequest, CenterBasedDeltaCalculator, CenterGroupOrNode, CenterGroupOrNodeRequest, CenterOfMassSelectionStrategy, ChainPushCollisionResolver, ClearSelection, ClearSelectionRequest, CompleteConnectionRedraw, CompleteConnectionRedrawRequest, ConnectedSubgraphScopeFilter, ConnectionBehaviourBuilder, ConnectionBehaviourBuilderRequest, ConnectionContentLayoutEngine, ConnectionLineBuilder, ConnectionLineBuilderRequest, ConnectionRedrawState, ConnectionWorkerState, CreateConnectionCreateDragHandler, CreateConnectionCreateDragHandlerRequest, CreateConnectionFinalize, CreateConnectionFinalizeRequest, CreateConnectionFromOutletPreparation, CreateConnectionFromOutletPreparationRequest, CreateConnectionFromOutputPreparation, CreateConnectionFromOutputPreparationRequest, CreateConnectionHandler, CreateConnectionMarkers, CreateConnectionMarkersRequest, CreateConnectionPreparation, CreateConnectionPreparationRequest, CreateDragNodeHandler, CreateDragNodeHandlerRequest, CreateDragNodeHierarchy, CreateDragNodeHierarchyRequest, DRAG_AND_DROP_COMMON_PROVIDERS, DRAG_AUTO_PAN_PROVIDERS, DRAG_CANVAS_PROVIDERS, DRAG_CONNECTIONS_PROVIDERS, DRAG_DROP_TO_GROUP_PROVIDERS, DRAG_EXTERNAL_ITEM_HANDLER_KIND, DRAG_EXTERNAL_ITEM_HANDLER_TYPE, DRAG_EXTERNAL_ITEM_PROVIDERS, DRAG_MINIMAP_HANDLER_KIND, DRAG_MINIMAP_HANDLER_TYPE, DRAG_MINIMAP_PROVIDERS, DRAG_NODE_HANDLER_KIND, DRAG_NODE_HANDLER_TYPE, DRAG_SELECTION_AREA_PROVIDERS, DRAG_SELECT_BY_POINTER_PROVIDERS, DeltaClamp, Deprecated, DetectConnectionsUnderDragNode, DetectConnectionsUnderDragNodeRequest, DisableConnectionWorker, DisableConnectionWorkerRequest, DownstreamConnectionsSelectionStrategy, DragAndDropBase, DragCanvasFinalize, DragCanvasFinalizeRequest, DragCanvasHandler, DragCanvasPreparation, DragCanvasPreparationRequest, DragConnectionWaypointFinalize, DragConnectionWaypointFinalizeRequest, DragConnectionWaypointHandler, DragConnectionWaypointPreparation, DragConnectionWaypointPreparationRequest, DragExternalItemCreatePlaceholder, DragExternalItemCreatePlaceholderRequest, DragExternalItemCreatePreview, DragExternalItemCreatePreviewRequest, DragExternalItemFinalize, DragExternalItemFinalizeRequest, DragExternalItemHandler, DragExternalItemPreparation, DragExternalItemPreparationRequest, DragHandlerBase, DragHandlerInjector, DragMinimapFinalize, DragMinimapFinalizeRequest, DragMinimapHandler, DragMinimapPreparation, DragMinimapPreparationRequest, DragNodeConnectionBothSidesHandler, DragNodeConnectionHandlerBase, DragNodeConnectionSourceHandler, DragNodeConnectionTargetHandler, DragNodeDeltaConstraints, DragNodeFinalize, DragNodeFinalizeRequest, DragNodeHandler, DragNodeHierarchy, DragNodeItemHandler, DragNodePreparation, DragNodePreparationRequest, DropToGroupFinalize, DropToGroupFinalizeRequest, DropToGroupHandler, DropToGroupPreparation, DropToGroupPreparationRequest, ECanvasRedrawContext, EFCanvasLayer, EFConnectableSide, EFConnectionBehavior, EFConnectionConnectableSide, EFConnectionType, EFFlowFeatureKind, EFLayoutDirection, EFLayoutMode, EFMarkerType, EFReflowAxis, EFReflowCollision, EFReflowDeltaSource, EFReflowMode, EFReflowScope, EFResizeHandleType, EFZoomDirection, EMPTY_REFLOW_PLAN, EdgeBasedDeltaCalculator, EmitConnectionsChanges, EmitConnectionsChangesRequest, EmitEndDragSequenceEvent, EmitEndDragSequenceEventRequest, EmitSelectionChangeEvent, EmitSelectionChangeEventRequest, EmitStartDragSequenceEvent, EmitStartDragSequenceEventRequest, EnsureConnectionWorker, EnsureConnectionWorkerRequest, EventExtensions, ExternalRectConstraint, FAutoPan, FAutoPanBase, FBackgroundBase, FBackgroundComponent, FCache, FCacheConnector, FCacheConnectorKeyFactory, FCacheNode, FCanvasBase, FCanvasChangeEvent, FCanvasComponent, FChannel, FChannelHub, FCirclePatternComponent, FComponentsStore, FConnectionBase, FConnectionComponent, FConnectionComponentsParent, FConnectionContent, FConnectionContentBase, FConnectionDragHandleBase, FConnectionDragHandleEnd, FConnectionDragHandleStart, FConnectionForCreateComponent, FConnectionGradient, FConnectionGradientBase, FConnectionGradientRenderer, FConnectionGradientRendererBase, FConnectionMarker, FConnectionMarkerArrow, FConnectionMarkerBase, FConnectionMarkerCircle, FConnectionMarkerRegistry, FConnectionPath, FConnectionPathBase, FConnectionRegistry, FConnectionSelection, FConnectionSelectionBase, FConnectionWaypoints, FConnectionWaypointsBase, FConnectionWaypointsChangedEvent, FConnectorBase, FConnectorRegistry, FCreateConnectionEvent, FCreateNodeEvent, FDragBlockerDirective, FDragExternalItemStartEventData, FDragHandleDirective, FDragHandlerResult, FDragNodeStartEventData, FDragStartedEvent, FDraggableBase, FDraggableDataContext, FDraggableDirective, FDropToGroupEvent, FExternalItem, FExternalItemBase, FExternalItemPlaceholder, FExternalItemPreview, FExternalItemService, FFlowBase, FFlowComponent, FFlowModule, FGroupDirective, FIdRegistryBase, FLayoutController, FLayoutEngine, FLineAlignmentComponent, FMagneticLines, FMagneticLinesBase, FMagneticRects, FMagneticRectsBase, FMinimapBase, FMinimapCanvasDirective, FMinimapComponent, FMinimapFlowDirective, FMinimapState, FMinimapViewDirective, FMoveNodesEvent, FNodeBase, FNodeConnectionsIntersectionEvent, FNodeDirective, FNodeInputBase, FNodeInputDirective, FNodeIntersectedWithConnections, FNodeOutletBase, FNodeOutletDirective, FNodeOutputBase, FNodeOutputDirective, FNodeRegistry, FReassignConnectionEvent, FRectPatternComponent, FReflowBaselineTracker, FReflowController, FReflowCycleGuard, FReflowIgnore, FReflowIgnoreRegistry, FReflowOrchestrator, FReflowPlanner, FResizeChannel, FResizeHandleDirective, FResizeNodeStartEventData, FRotateHandleDirective, FRotateNodeStartEventData, FSelectionArea, FSelectionAreaBase, FSelectionChangeEvent, FSingleRegistryBase, FSnapConnectionComponent, FSourceConnectorBase, FVirtualFor, FZoomBase, FZoomDirective, F_AUTO_PAN_PROVIDERS, F_BACKGROUND, F_BACKGROUND_FEATURES, F_BACKGROUND_PATTERN, F_BACKGROUND_PROVIDERS, F_CACHE_FEATURES, F_CACHE_OPTIONS, F_CANVAS, F_CANVAS_CONFIG, F_CANVAS_FEATURES, F_CANVAS_PROVIDERS, F_CONNECTION_BUILDERS, F_CONNECTION_COMPONENTS_PARENT, F_CONNECTION_CONTENT, F_CONNECTION_DRAG_HANDLE_END, F_CONNECTION_DRAG_HANDLE_START, F_CONNECTION_FEATURES, F_CONNECTION_GRADIENT, F_CONNECTION_IMPORTS_EXPORTS, F_CONNECTION_MARKER, F_CONNECTION_PATH, F_CONNECTION_PROVIDERS, F_CONNECTION_SELECTION, F_CONNECTION_WAYPOINTS, F_CONNECTORS_FEATURES, F_CONNECTORS_PROVIDERS, F_CSS_CLASS, F_DEFAULT_LAYER_ORDER, F_DRAGGABLE_FEATURES, F_DRAGGABLE_PROVIDERS, F_EXTERNAL_ITEM, F_EXTERNAL_ITEM_PROVIDERS, F_FLOW, F_FLOW_CONFIG, F_FLOW_FEATURES, F_FLOW_PROVIDERS, F_LAYOUT, F_LAYOUT_OPTIONS, F_LINE_ALIGNMENT_PROVIDERS, F_MAGNETIC_LINES, F_MAGNETIC_LINES_PROVIDERS, F_MAGNETIC_RECTS, F_MAGNETIC_RECTS_PROVIDERS, F_MINIMAP_BASE, F_MINIMAP_FEATURES, F_MINIMAP_PROVIDERS, F_NODE, F_NODE_FEATURES, F_NODE_INPUT, F_NODE_OUTLET, F_NODE_OUTPUT, F_NODE_PROVIDERS, F_REFLOW_CONFIG, F_REFLOW_PROVIDERS, F_SELECTED_CLASS, F_SELECTION_AREA_PROVIDERS, F_SELECTION_FEATURES, F_STORAGE_PROVIDERS, F_VIRTUAL_FOR_PROVIDERS, F_ZOOM, F_ZOOM_FEATURES, F_ZOOM_PROVIDERS, FindConnectableConnectorUsingPriorityAndPosition, FindConnectableConnectorUsingPriorityAndPositionRequest, FitToChildNodesAndGroups, FitToChildNodesAndGroupsRequest, FitToFlow, FitToFlowRequest, GET_FLOW_STATE_PROVIDERS, GetCachedFCacheRect, GetCachedFCacheRectRequest, GetChildNodeIds, GetChildNodeIdsRequest, GetConnectorRectReference, GetConnectorRectReferenceRequest, GetCurrentSelection, GetCurrentSelectionRequest, GetDeepChildrenNodesAndGroups, GetDeepChildrenNodesAndGroupsRequest, GetFlow, GetFlowRequest, GetNodePadding, GetNodePaddingRequest, GetNormalizedConnectorRect, GetNormalizedConnectorRectRequest, GetNormalizedElementRect, GetNormalizedElementRectRequest, GetNormalizedParentNodeRect, GetNormalizedParentNodeRectRequest, GetNormalizedPoint, GetNormalizedPointRequest, GetParentNodes, GetParentNodesRequest, GlobalScopeFilter, GridSnapper, GroupScopeFilter, HandleConnectionWorkerMessage, HandleConnectionWorkerMessageRequest, IMouseEvent, INSTANCES, IPointerEvent, IPointerUpEvent, ITouchDownEvent, ITouchMoveEvent, InitializeDragSequence, InitializeDragSequenceRequest, InputCanvasPosition, InputCanvasPositionRequest, InputCanvasScale, InputCanvasScaleRequest, InvalidateFCacheNode, InvalidateFCacheNodeRequest, IsArrayHasParentNode, IsArrayHasParentNodeRequest, IsConnectionRedrawCurrent, IsConnectionRedrawCurrentRequest, IsConnectionWorkerEnabled, IsConnectionWorkerEnabledRequest, IsDragStarted, IsDragStartedRequest, ListenConnectionsChanges, ListenConnectionsChangesRequest, ListenNodesChanges, ListenNodesChangesRequest, ListenTransformChanges, ListenTransformChangesRequest, LogExecutionTime, MOUSE_EVENT_IGNORE_TIME, MagneticLineElement, MagneticLineRenderer, MagneticLinesHandler, MagneticLinesPreparation, MagneticLinesPreparationRequest, MagneticRectElement, MagneticRectsHandler, MagneticRectsPreparation, MagneticRectsPreparationRequest, MagneticRectsRenderer, MarkConnectableConnectors, MarkConnectableConnectorsRequest, MarkConnectionConnectorsAsConnected, MarkConnectionConnectorsAsConnectedRequest, MinimapCalculateViewRect, MinimapCalculateViewRectRequest, MinimapCalculateViewport, MinimapCalculateViewportRequest, MinimapDrawNodes, MinimapDrawNodesRequest, MoveFrontElementsBeforeTargetElement, MoveFrontElementsBeforeTargetElementRequest, NODE_PROVIDERS, NODE_RESIZE_PROVIDERS, NODE_ROTATE_PROVIDERS, NotifyFullRendered, NotifyFullRenderedRequest, NotifyNodesRendered, NotifyNodesRenderedRequest, NotifyTransformChanged, NotifyTransformChangedRequest, OnPointerMove, OnPointerMoveRequest, PINCH_TO_ZOOM_PROVIDERS, PinchToZoomFinalize, PinchToZoomFinalizeRequest, PinchToZoomHandler, PinchToZoomPreparation, PinchToZoomPreparationRequest, Polyline, PolylineContentAlign, PolylineContentPlace, PolylineSampler, PrepareDragSequence, PrepareDragSequenceRequest, PreventDefaultIsExternalItem, PreventDefaultIsExternalItemRequest, QueueConnectionRedraw, QueueConnectionRedrawRequest, QueueConnectionRedrawState, RESIZE_DIRECTIONS, RESIZE_NODE_HANDLER_KIND, RESIZE_NODE_HANDLER_TYPE, ROTATE_NODE_HANDLER_KIND, ROTATE_NODE_HANDLER_TYPE, ReadNodeBoundsWithPaddings, ReadNodeBoundsWithPaddingsRequest, ReadNodeBoundsWithPaddingsResponse, ReassignConnectionFinalize, ReassignConnectionFinalizeRequest, ReassignConnectionHandler, ReassignConnectionPreparation, ReassignConnectionPreparationRequest, ReassignConnectionSourceHandler, ReassignConnectionTargetHandler, RedrawCanvasWithAnimation, RedrawCanvasWithAnimationRequest, RedrawConnections, RedrawConnectionsRequest, RegisterFCacheConnector, RegisterFCacheConnectorRequest, RegisterFCacheNode, RegisterFCacheNodeRequest, RegisterPluginInstance, RegisterPluginInstanceRequest, RemoveCanvasFromStore, RemoveCanvasFromStoreRequest, RemoveConnectionForCreateFromStore, RemoveConnectionForCreateFromStoreRequest, RemoveConnectionFromStore, RemoveConnectionFromStoreRequest, RemoveConnectionMarkerFromStore, RemoveConnectionMarkerFromStoreRequest, RemoveConnectionWaypoint, RemoveConnectionWaypointRequest, RemoveConnectorFromStore, RemoveConnectorFromStoreRequest, RemoveDndFromStore, RemoveDndFromStoreRequest, RemoveFlowFromStore, RemoveFlowFromStoreRequest, RemoveNodeFromStore, RemoveNodeFromStoreRequest, RemovePluginInstance, RemovePluginInstanceRequest, RemoveSnapConnectionFromStore, RemoveSnapConnectionFromStoreRequest, RenderConnection, RenderConnectionFromGeometry, RenderConnectionFromGeometryRequest, RenderConnectionRequest, RenderConnectionWithLine, RenderConnectionWithLineRequest, RenderLifecycleState, ResetConnectionWorkerRuntime, ResetConnectionWorkerRuntimeRequest, ResetRenderLifecycle, ResetRenderLifecycleRequest, ResetScale, ResetScaleAndCenter, ResetScaleAndCenterRequest, ResetScaleRequest, ResetZoom, ResetZoomRequest, ResizeNodeConnectionBothSidesHandler, ResizeNodeConnectionHandlerBase, ResizeNodeConnectionSourceHandler, ResizeNodeConnectionTargetHandler, ResizeNodeFinalize, ResizeNodeFinalizeRequest, ResizeNodeHandler, ResizeNodePreparation, ResizeNodePreparationRequest, ResolveConnectableOutputForOutlet, ResolveConnectableOutputForOutletRequest, ResolveConnectionEndpointRect, ResolveConnectionEndpointRectRequest, ResolveConnectionEndpointRotationContext, ResolveConnectionEndpointRotationContextRequest, ResolveConnectionEndpoints, ResolveConnectionEndpointsRequest, ResolveConnectionGeometry, ResolveConnectionGeometryRequest, RotateNodeFinalize, RotateNodeFinalizeRequest, RotateNodeHandler, RotateNodePreparation, RotateNodePreparationRequest, RunAutoPanFrame, RunAutoPanFrameRequest, RunConnectionRedrawSlice, RunConnectionRedrawSliceRequest, RunConnectionWorker, RunConnectionWorkerBatch, RunConnectionWorkerBatchRequest, RunConnectionWorkerRequest, ScheduleAutoPanFrame, ScheduleAutoPanFrameRequest, Select, SelectAll, SelectAllRequest, SelectAndUpdateNodeLayer, SelectAndUpdateNodeLayerRequest, SelectByPointer, SelectByPointerRequest, SelectRequest, SelectionAreaFinalize, SelectionAreaFinalizeRequest, SelectionAreaHandler, SelectionAreaPreparation, SelectionAreaPreparationRequest, SetBackgroundTransform, SetBackgroundTransformRequest, SetFCacheConnectorRect, SetFCacheConnectorRectRequest, SetFCacheNodeRect, SetFCacheNodeRectRequest, SetZoom, SetZoomRequest, ShouldUseConnectionWorker, ShouldUseConnectionWorkerRequest, SortDropCandidatesByLayer, SortDropCandidatesByLayerRequest, SortItemLayers, SortItemLayersRequest, SortItemsByParent, SortItemsByParentRequest, SortNodeLayers, SortNodeLayersRequest, StartConnectionRedraw, StartConnectionRedrawRequest, StartConnectionWorkerRedraw, StartConnectionWorkerRedrawRequest, StopAutoPan, StopAutoPanRequest, StopCollisionResolver, UnmarkConnectableConnectors, UnmarkConnectableConnectorsRequest, UnregisterFCacheConnector, UnregisterFCacheConnectorRequest, UnregisterFCacheNode, UnregisterFCacheNodeRequest, UpdateFCacheRectByElement, UpdateFCacheRectByElementRequest, UpdateItemAndChildrenLayers, UpdateItemAndChildrenLayersRequest, UpdateNodeWhenStateOrSizeChanged, UpdateNodeWhenStateOrSizeChangedRequest, UpdateScale, UpdateScaleRequest, WaitForConnectionsRendered, WaitForConnectionsRenderedRequest, XRangeSelectionStrategy, afterNextPaint, buildConnectionAnchors, buildCornerMidPointsAndApplyOffsets, calculateAutoPanAxisDelta, calculateAutoPanDelta, calculateCenterBetweenPoints, calculateCurveCandidates, calculateDifferenceAfterRotation, calculateMagneticGuides, calculateMagneticRects, calculatePointerInFlow, calculatePolylineCandidates, calculatePositionAfterRotation, coerceMarkerType, computeEdgeDeltas, createConnectionDomIdentifier, createConnectionSelectionDomIdentifier, createConnectionWorkerUrl, createGradientDomIdentifier, createGradientDomUrl, createMultiCubicPath, createSVGElement, createSegmentLinePath, cubicBezierAtT, debounceAnimationFrame, debounceMicrotask, debounceTime, defaultEventTrigger, determineSide, expandRectByOverflow, fInstanceKey, fProvideCache, findExistingWaypoint, findWaypointCandidate, fixedCenterBehavior, fixedOutboundBehavior, floatingBehavior, getExternalItemHost, infinityMinMax, isCalculateMode, isConnectionWorkerRuntimeSupported, isDragBlocker, isDragExternalItemHandler, isDragHandleEnd, isDragHandleStart, isDragMinimapHandler, isDragNodeHandler, isExternalItem, isMobile, isNode, isNodeOutlet, isNodeOutput, isPointerInsidePoint, isPointerInsideStartOrEndDragHandles, isResizeNodeHandler, isRotateHandle, isRotateNodeHandler, isValidEventTrigger, mergeFCanvasConfig, mergeLayoutNodes, mergePointChains, mergeReflowConfig, mixinChangeSelection, mixinChangeVisibility, normalizeFlowLayoutData, normalizePolyline, notifyOnStart, pickWaypoint, provideFFlow, provideFLayout, rebaseAutoPanPointerDownPosition, rectFromPoint, resolveAutoPanMode, resolveConnectionWorkerRuntime, resolveLayerOrder, revokeConnectionWorkerUrl, sampleCubicBezierUniform, sampleMultiCubicUniform, stringAttribute, takeOne, transitionEnd, withFCanvas, withReflowOnResize, withinSnapThreshold };
export type { AbstractConstructor, Constructor, FCacheConnectorKey, FChannelListener, FChannelOperator, FConnectionEndpoint, FConnectorKind, FEventTrigger, FHasId, FInstanceKey, FMoveNodePosition, FTriggerEvent, ICacheOptions, ICalculateBehaviorRequest, ICanBeSelectedElementAndRect, ICanChangeVisibility, IClosestConnectorRef, IConnectionBuilders, IConnectionEndpointRotationContext, IConnectionEndpoints, IConnectionGeometry, IConnectionRedrawSession, IConnectionWorkerBatch, IConnectionWorkerBatchItem, IConnectionWorkerPayloadItem, IConnectionWorkerRect, IConnectionWorkerResponse, IConnectionWorkerResultItem, IConnectorRectRef, IConstraintEdges, ICreateConnectionDragResult, ICreateConnectionEventData, ICubicSegment, ICurrentSelection, IDeltaClampResult, IDestroyable, IDragExternalItemDragResult, IDragNodeDeltaConstraints, IDragNodeDeltaConstraintsResult, IDragNodeSoftConstraint, IDragSessionContext, IDragSessionFeature, IFBackgroundPattern, IFCacheNodeRef, IFCanvasResolvedConfig, IFConnectionBuilder, IFConnectionBuilderRequest, IFConnectionBuilderResponse, IFFlowConfig, IFFlowFeature, IFFlowState, IFFlowStateConnection, IFFlowStateConnector, IFFlowStateNode, IFFlowStateOptions, IFLayoutAlgorithmOptions, IFLayoutCalculationOptions, IFLayoutConnection, IFLayoutGraph, IFLayoutNode, IFLayoutNodePosition, IFLayoutOptions, IFLayoutProviderConfig, IFLayoutResult, IFLayoutWritebackPayload, IFReflowCollisionResolver, IFReflowDeltaCalculator, IFReflowOnResizeConfig, IFReflowOnResizeResolvedConfig, IFReflowScopeFilter, IFReflowSelectionStrategy, IFReflowSpacingConfig, IFlowLayoutNormalizationResult, IHasHostElement, IMagneticAxisGuide, IMagneticGapRect, IMagneticGuidesResult, IMagneticRectsResult, IMinimapViewport, INodeWithRect, IParentConnectionEndpointHandler, IParentConnectionHandlers, IPolylineContent, IReassignConnectionDragResult, IReassignConnectionEventData, IReassignHandler, IReflowCandidate, IReflowConnection, IReflowPlan, IReflowPlannerInput, IReflowRawShift, IReflowResolvedShift, IReflowShift, IResizeConstraint, IResizeEdgeDeltas, IResizeLimit, IResizeLimits, IResizeNodeConnectionEndpointHandler, IResizeNodeConnectionHandlers, IResizeOverflow, ISamplerResult, ISelectable, ITangent, MagneticRectsAlignMode, MagneticRectsAxis, MergeFCanvasConfig, TAutoPanMode, TCalculateMode, TConnectionWorkerPendingRequest, TFLayoutWritebackHandler, TResolveConnectionEndpointRotationContextResponse, WaypointPick };