@foblex/flow 17.9.81 → 18.1.0

package/f-draggable/connection/create-connection/create-connection-preparation/create-drag-handler/index.d.ts

@@ -0,0 +1,2 @@
+export * from './create-connection-create-drag-handler';
+export * from './create-connection-create-drag-handler-request';

package/f-draggable/connection/create-connection/create-connection-preparation/from-outlet-preparation/create-connection-from-outlet-preparation-request.d.ts

@@ -0,0 +1,8 @@
+import { FNodeBase } from '../../../../../f-node';
+import { IPointerEvent } from '../../../../../drag-toolkit';
+export declare class CreateConnectionFromOutletPreparationRequest {
+    readonly event: IPointerEvent;
+    readonly node: FNodeBase;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent, node: FNodeBase);
+}

package/f-draggable/connection/create-connection/create-connection-preparation/from-outlet-preparation/create-connection-from-outlet-preparation.d.ts

@@ -0,0 +1,14 @@
+import { IHandler } from '@foblex/mediator';
+import { CreateConnectionFromOutletPreparationRequest } from './create-connection-from-outlet-preparation-request';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/f-draggable/connection/create-connection/create-connection-preparation/from-outlet-preparation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './create-connection-from-outlet-preparation';
+export * from './create-connection-from-outlet-preparation-request';

package/f-draggable/connection/create-connection/create-connection-preparation/from-output-preparation/create-connection-from-output-preparation.d.ts

@@ -0,0 +1,13 @@
+import { IHandler } from '@foblex/mediator';
+import { CreateConnectionFromOutputPreparationRequest } from './create-connection-from-output-preparation-request';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/f-draggable/connection/create-connection/create-connection-preparation/index.d.ts

@@ -0,0 +1,5 @@
+export * from './create-drag-handler';
+export * from './from-outlet-preparation';
+export * from './from-output-preparation';
+export * from './create-connection-preparation';
+export * from './create-connection-preparation-request';

package/f-draggable/connection/create-connection/f-create-connection-event.d.ts

@@ -0,0 +1,16 @@
+import { IPoint } from '@foblex/2d';
+export 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);
+}

package/f-draggable/connection/create-connection/i-create-connection-drag-result.d.ts

@@ -0,0 +1,7 @@
+import { RoundedRect } from '@foblex/2d';
+import { IConnectorRectRef } from '../../../domain';
+export interface ICreateConnectionDragResult {
+    toConnectorRect: RoundedRect;
+    fOutputId: string;
+    canBeConnectedInputs: IConnectorRectRef[];
+}

package/f-draggable/connection/create-connection/i-create-connection-event-data.d.ts

@@ -0,0 +1,3 @@
+export interface ICreateConnectionEventData {
+    fOutputOrOutletId: string;
+}

package/f-draggable/connection/create-connection/index.d.ts

@@ -0,0 +1,7 @@
+export * from './create-connection-finalize';
+export * from './create-connection-preparation';
+export * from './resolve-connectable-output-for-outlet';
+export * from './create-connection-handler';
+export * from './f-create-connection-event';
+export * from './i-create-connection-event-data';
+export * from './i-create-connection-drag-result';

package/f-draggable/connection/create-connection/resolve-connectable-output-for-outlet/index.d.ts

@@ -0,0 +1,2 @@
+export * from './resolve-connectable-output-for-outlet';
+export * from './resolve-connectable-output-for-outlet-request';

package/f-draggable/connection/create-connection/resolve-connectable-output-for-outlet/resolve-connectable-output-for-outlet-request.d.ts

@@ -0,0 +1,6 @@
+import { FNodeOutletBase } from '../../../../f-connectors';
+export declare class ResolveConnectableOutputForOutletRequest {
+    readonly outlet: FNodeOutletBase;
+    static readonly fToken: unique symbol;
+    constructor(outlet: FNodeOutletBase);
+}

package/f-draggable/connection/create-connection/resolve-connectable-output-for-outlet/resolve-connectable-output-for-outlet.d.ts

@@ -0,0 +1,12 @@
+import { IHandler } from '@foblex/mediator';
+import { FConnectorBase } from '../../../../f-connectors';
+import { ResolveConnectableOutputForOutletRequest } from './resolve-connectable-output-for-outlet-request';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-finalize/drag-connection-waypoint-finalize-request.d.ts

@@ -0,0 +1,6 @@
+import { IPointerEvent } from '../../../../drag-toolkit';
+export declare class DragConnectionWaypointFinalizeRequest {
+    readonly event: IPointerEvent;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent);
+}

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-finalize/drag-connection-waypoint-finalize.d.ts

@@ -0,0 +1,11 @@
+import { DragConnectionWaypointFinalizeRequest } from './drag-connection-waypoint-finalize-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-finalize/index.d.ts

@@ -0,0 +1,2 @@
+export * from './drag-connection-waypoint-finalize';
+export * from './drag-connection-waypoint-finalize-request';

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-handler/drag-connection-waypoint-handler.d.ts

@@ -0,0 +1,21 @@
+import { IPoint } from '@foblex/2d';
+import { DragHandlerBase } from '../../../infrastructure';
+import { FConnectionBase, WaypointPick } from '../../../../f-connection-v2';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-handler/index.d.ts

@@ -0,0 +1 @@
+export * from './drag-connection-waypoint-handler';

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-preparation/drag-connection-waypoint-preparation-request.d.ts

@@ -0,0 +1,8 @@
+import { IPointerEvent } from '../../../../drag-toolkit';
+import { FEventTrigger } from '../../../../domain';
+export declare class DragConnectionWaypointPreparationRequest {
+    readonly event: IPointerEvent;
+    readonly fTrigger: FEventTrigger;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
+}

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-preparation/drag-connection-waypoint-preparation.d.ts

@@ -0,0 +1,19 @@
+import { DragConnectionWaypointPreparationRequest } from './drag-connection-waypoint-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/f-draggable/connection/drag-connection-waypoint/drag-connection-waypoint-preparation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './drag-connection-waypoint-preparation';
+export * from './drag-connection-waypoint-preparation-request';

package/f-draggable/connection/drag-connection-waypoint/f-connection-waypoints-changed-event.d.ts

@@ -0,0 +1,6 @@
+import { IPoint } from '@foblex/2d';
+export declare class FConnectionWaypointsChangedEvent {
+    readonly connectionId: string;
+    readonly waypoints: IPoint[];
+    constructor(connectionId: string, waypoints: IPoint[]);
+}

package/f-draggable/connection/drag-connection-waypoint/index.d.ts

@@ -0,0 +1,4 @@
+export * from './drag-connection-waypoint-finalize';
+export * from './drag-connection-waypoint-preparation';
+export * from './drag-connection-waypoint-handler';
+export * from './f-connection-waypoints-changed-event';

package/f-draggable/connection/index.d.ts

@@ -0,0 +1,4 @@
+export * from './create-connection';
+export * from './reassign-connection';
+export * from './drag-connection-waypoint';
+export * from './providers';

package/f-draggable/connection/providers.d.ts

@@ -0,0 +1,4 @@
+import { CreateConnectionFromOutputPreparation, CreateConnectionPreparation, CreateConnectionCreateDragHandler, CreateConnectionFinalize, CreateConnectionFromOutletPreparation, ResolveConnectableOutputForOutlet } from './create-connection';
+import { ReassignConnectionFinalize, ReassignConnectionPreparation } from './reassign-connection';
+import { DragConnectionWaypointFinalize, DragConnectionWaypointPreparation } from './drag-connection-waypoint';
+export 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)[];

package/f-draggable/connection/reassign-connection/f-reassign-connection-event.d.ts

@@ -0,0 +1,29 @@
+import { IPoint } from '@foblex/2d';
+export type FConnectionEndpoint = 'source' | 'target';
+export 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);
+}

package/f-draggable/connection/reassign-connection/i-reassign-connection-drag-result.d.ts

@@ -0,0 +1,17 @@
+import { RoundedRect } from '@foblex/2d';
+import { IConnectorRectRef } from '../../../domain';
+import { FConnectionBase } from '../../../f-connection-v2';
+export 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[];
+}

package/f-draggable/connection/reassign-connection/i-reassign-connection-event-data.d.ts

@@ -0,0 +1,3 @@
+export interface IReassignConnectionEventData {
+    fConnectionId: string;
+}

package/f-draggable/connection/reassign-connection/index.d.ts

@@ -0,0 +1,6 @@
+export * from './reassign-connection-finalize';
+export * from './reassign-connection-preparation';
+export * from './reassign-connection-handler';
+export * from './f-reassign-connection-event';
+export * from './i-reassign-connection-drag-result';
+export * from './i-reassign-connection-event-data';

package/f-draggable/connection/reassign-connection/reassign-connection-finalize/index.d.ts

@@ -0,0 +1,2 @@
+export * from './reassign-connection-finalize';
+export * from './reassign-connection-finalize-request';

package/f-draggable/connection/reassign-connection/reassign-connection-finalize/reassign-connection-finalize-request.d.ts

@@ -0,0 +1,6 @@
+import { IPointerEvent } from '../../../../drag-toolkit';
+export declare class ReassignConnectionFinalizeRequest {
+    readonly event: IPointerEvent;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent);
+}

package/f-draggable/connection/reassign-connection/reassign-connection-finalize/reassign-connection-finalize.d.ts

@@ -0,0 +1,18 @@
+import { ReassignConnectionFinalizeRequest } from './reassign-connection-finalize-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/f-draggable/connection/reassign-connection/reassign-connection-handler/i-reassign-handler.d.ts

@@ -0,0 +1,15 @@
+import { IPoint, RoundedRect } from '@foblex/2d';
+import { FSnapConnectionComponent } from '../../../../f-connection';
+import { IClosestConnectorRef, IConnectorRectRef } from '../../../../domain';
+export 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;
+}
+export declare function withinSnapThreshold(fClosestConnector: IClosestConnectorRef | undefined, snapConnection: FSnapConnectionComponent): IClosestConnectorRef | undefined;
+export declare function rectFromPoint(point: IPoint): RoundedRect;

package/f-draggable/connection/reassign-connection/reassign-connection-handler/index.d.ts

@@ -0,0 +1,4 @@
+export * from './reassign-connection-source-handler';
+export * from './reassign-connection-target-handler';
+export * from './i-reassign-handler';
+export * from './reassign-connection-handler';

package/f-draggable/connection/reassign-connection/reassign-connection-handler/reassign-connection-handler.d.ts

@@ -0,0 +1,30 @@
+import { DragHandlerBase } from '../../../infrastructure';
+import { IReassignConnectionEventData } from '../i-reassign-connection-event-data';
+import { FConnectionBase } from '../../../../f-connection-v2';
+import { IPoint } from '@foblex/2d';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/f-draggable/connection/reassign-connection/reassign-connection-handler/reassign-connection-source-handler.d.ts

@@ -0,0 +1,27 @@
+import { FMediator } from '@foblex/mediator';
+import { IConnectorRectRef } from '../../../../domain';
+import { FSnapConnectionComponent } from '../../../../f-connection';
+import { IPoint } from '@foblex/2d';
+import { IReassignHandler } from './i-reassign-handler';
+import { ConnectionBehaviourBuilder, FConnectionBase } from '../../../../f-connection-v2';
+export 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;
+}

package/f-draggable/connection/reassign-connection/reassign-connection-handler/reassign-connection-target-handler.d.ts

@@ -0,0 +1,27 @@
+import { FMediator } from '@foblex/mediator';
+import { IConnectorRectRef } from '../../../../domain';
+import { FSnapConnectionComponent } from '../../../../f-connection';
+import { IPoint } from '@foblex/2d';
+import { IReassignHandler } from './i-reassign-handler';
+import { ConnectionBehaviourBuilder, FConnectionBase } from '../../../../f-connection-v2';
+export 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;
+}

package/f-draggable/connection/reassign-connection/reassign-connection-preparation/index.d.ts

@@ -0,0 +1,3 @@
+export * from './reassign-connection-preparation';
+export * from './reassign-connection-preparation-request';
+export * from './is-pointer-inside-start-or-end-drag-handles';

package/f-draggable/connection/reassign-connection/reassign-connection-preparation/is-pointer-inside-start-or-end-drag-handles.d.ts

@@ -0,0 +1,5 @@
+import { IPoint } from '@foblex/2d';
+import { FConnectionBase } from '../../../../f-connection-v2';
+export declare function isPointerInsideStartOrEndDragHandles(connection: FConnectionBase, position: IPoint): boolean;
+export declare function isDragHandleEnd(connection: FConnectionBase, position: IPoint): boolean;
+export declare function isDragHandleStart(connection: FConnectionBase, position: IPoint): boolean;

package/f-draggable/connection/reassign-connection/reassign-connection-preparation/reassign-connection-preparation-request.d.ts

@@ -0,0 +1,8 @@
+import { FEventTrigger } from '../../../../domain';
+import { IPointerEvent } from '../../../../drag-toolkit';
+export declare class ReassignConnectionPreparationRequest {
+    readonly event: IPointerEvent;
+    readonly fTrigger: FEventTrigger;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
+}

package/f-draggable/connection/reassign-connection/reassign-connection-preparation/reassign-connection-preparation.d.ts

@@ -0,0 +1,20 @@
+import { ReassignConnectionPreparationRequest } from './reassign-connection-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/f-draggable/domain/detect-connections-under-drag-node/detect-connections-under-drag-node-request.d.ts

@@ -0,0 +1,6 @@
+import { FNodeBase } from '../../../f-node';
+export declare class DetectConnectionsUnderDragNodeRequest {
+    readonly nodeOrGroup: FNodeBase;
+    static readonly fToken: unique symbol;
+    constructor(nodeOrGroup: FNodeBase);
+}

package/f-draggable/domain/detect-connections-under-drag-node/detect-connections-under-drag-node.d.ts

@@ -0,0 +1,14 @@
+import { IExecution } from '@foblex/mediator';
+import { DetectConnectionsUnderDragNodeRequest } from './detect-connections-under-drag-node-request';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/f-draggable/domain/detect-connections-under-drag-node/f-node-intersected-with-connections-event.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @deprecated Use `FNodeConnectionsIntersectionEvent`.
+ * Will be removed in a future major release.
+ */
+export 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.
+ */
+export declare class FNodeConnectionsIntersectionEvent extends FNodeIntersectedWithConnections {
+    readonly nodeId: string;
+    readonly connectionIds: string[];
+    constructor(nodeId: string, connectionIds: string[]);
+}

package/f-draggable/domain/detect-connections-under-drag-node/index.d.ts

@@ -0,0 +1,3 @@
+export * from './f-node-intersected-with-connections-event';
+export * from './detect-connections-under-drag-node';
+export * from './detect-connections-under-drag-node-request';

package/f-draggable/domain/emit-end-drag-sequence-event/emit-end-drag-sequence-event-request.d.ts

@@ -0,0 +1,3 @@
+export declare class EmitEndDragSequenceEventRequest {
+    static readonly fToken: unique symbol;
+}

package/f-draggable/domain/emit-end-drag-sequence-event/emit-end-drag-sequence-event.d.ts

@@ -0,0 +1,14 @@
+import { IExecution } from '@foblex/mediator';
+import { EmitEndDragSequenceEventRequest } from './emit-end-drag-sequence-event-request';
+import * as i0 from "@angular/core";
+/**
+ * Execution that handles the end of a drag sequence.
+ */
+export 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>;
+}

package/f-draggable/domain/emit-end-drag-sequence-event/index.d.ts

@@ -0,0 +1,2 @@
+export * from './emit-end-drag-sequence-event';
+export * from './emit-end-drag-sequence-event-request';

package/f-draggable/domain/emit-selection-change-event/emit-selection-change-event.d.ts

@@ -0,0 +1,17 @@
+import { IExecution } from '@foblex/mediator';
+import { EmitSelectionChangeEventRequest } from './emit-selection-change-event-request';
+import * as i0 from "@angular/core";
+/**
+ * Execution that emits a selection change event when the selection changes.
+ * It retrieves the current selection and emits it through the FSelectionChangeEvent.
+ */
+export 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>;
+}

package/f-draggable/domain/emit-selection-change-event/index.d.ts

@@ -0,0 +1,2 @@
+export * from './emit-selection-change-event';
+export * from './emit-selection-change-event-request';

package/f-draggable/domain/emit-start-drag-sequence-event/emit-start-drag-sequence-event-request.d.ts

@@ -0,0 +1,3 @@
+export declare class EmitStartDragSequenceEventRequest {
+    static readonly fToken: unique symbol;
+}

package/f-draggable/domain/emit-start-drag-sequence-event/emit-start-drag-sequence-event.d.ts

@@ -0,0 +1,15 @@
+import { IExecution } from '@foblex/mediator';
+import { EmitStartDragSequenceEventRequest } from './emit-start-drag-sequence-event-request';
+import * as i0 from "@angular/core";
+/**
+ * Execution that starts the drag sequence by adding a dragging class to the host element
+ */
+export 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>;
+}

package/f-draggable/domain/emit-start-drag-sequence-event/index.d.ts

@@ -0,0 +1,2 @@
+export * from './emit-start-drag-sequence-event';
+export * from './emit-start-drag-sequence-event-request';