@acorex/modules 21.0.0-next.51 → 21.0.0-next.54

package/types/acorex-modules-platform-management.d.ts

@@ -1,23 +1,24 @@
-import * as i0 from '@angular/core';
-import { Injector } from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { Injector, TemplateRef, ElementRef } from '@angular/core';
 import * as i1 from '@acorex/platform/workflow';
 import { AXPEntity } from '@acorex/platform/common';
 import { AXPEntityModel, AXMEntityCrudServiceImpl } from '@acorex/platform/layout/entity';
 import { AXPInterfaceDefinitionValue } from '@acorex/platform/domain';
 import { AXPCategoryListItem } from '@acorex/platform/core';
+import { AXStyleColorType } from '@acorex/cdk/common';
 
 declare class AXPUpdaterService {
     constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPUpdaterService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPUpdaterService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPUpdaterService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPUpdaterService>;
 }
 
 declare class AXMUpdaterModule {
     private updaterService;
     constructor(updaterService: AXPUpdaterService);
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXMUpdaterModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMUpdaterModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AXMUpdaterModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMUpdaterModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMUpdaterModule, never, never, never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMUpdaterModule>;
 }
 
 /**
@@ -25,9 +26,9 @@ declare class AXMUpdaterModule {
  * Provides token definition providers (static and dynamic) and refresh listeners.
  */
 declare class AXMTokenModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTokenModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMTokenModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AXMTokenModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMTokenModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMTokenModule, never, never, never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMTokenModule>;
 }
 
 /**
@@ -35,21 +36,21 @@ declare class AXMTokenModule {
  * and related workflows.
  */
 declare class AXMMenuManagementModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXMMenuManagementModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMMenuManagementModule, never, [typeof i1.AXPWorkflowModule], never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AXMMenuManagementModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMMenuManagementModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMMenuManagementModule, never, [typeof i1.AXPWorkflowModule], never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMMenuManagementModule>;
 }
 
 declare class AXMTokenEntityModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTokenEntityModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMTokenEntityModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AXMTokenEntityModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMTokenEntityModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMTokenEntityModule, never, never, never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMTokenEntityModule>;
 }
 
 declare class AXMPlatformManagementModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXMPlatformManagementModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMPlatformManagementModule, never, [typeof AXMUpdaterModule, typeof AXMTokenModule, typeof AXMMenuManagementModule, typeof AXMTokenEntityModule], never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AXMPlatformManagementModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMPlatformManagementModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMPlatformManagementModule, never, [typeof AXMUpdaterModule, typeof AXMTokenModule, typeof AXMMenuManagementModule, typeof AXMTokenEntityModule], never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMPlatformManagementModule>;
 }
 
 declare const RootConfig: {
@@ -223,8 +224,8 @@ declare abstract class AXMTokensService extends AXMEntityCrudServiceImpl<string,
 }
 declare class AXMTokensServiceImpl extends AXMEntityCrudServiceImpl<string, AXMTokenEntityModel> {
     constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTokensServiceImpl, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTokensServiceImpl>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMTokensServiceImpl, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMTokensServiceImpl>;
 }
 
 declare function validationDefinitionEntityFactory(injector: Injector): Promise<AXPEntity | null>;
@@ -235,5 +236,499 @@ declare const AXPPlatformManagementFeatureKeys: {
     readonly MaxTokens: "PlatformManagement:Feature:max-tokens";
 };
 
-export { AXMPlatformManagementModule, AXMTokenEntityModule, AXMTokensService, AXMTokensServiceImpl, AXPPlatformManagementFeatureKeys, RootConfig, aggregateDefinitionEntityFactory, commandDefinitionEntityFactory, interfaceDefinitionEntityFactory, interfaceDefinitionFromWidgetFieldConfiguratorValue, mapEntityFieldRowsInterfaceForForm, mapEntityFieldRowsInterfaceToDomain, menuDefinitionEntityFactory, moduleDefinitionEntityFactory, permissionGroupDefinitionEntityFactory, pluginDefinitionEntityFactory, queryDefinitionEntityFactory, relationDefinitionEntityFactory, toWidgetFieldConfiguratorColumnNode, tokenEntityFactory, validationDefinitionEntityFactory, widgetFieldConfiguratorValueFromInterfaceDefinition };
-export type { AXMEntityDefinitionEntityModel, AXMTokenDataType, AXMTokenEntityModel, AXMTokenFormat, AXMTokenKind, SchemaInterfaceFormValue };
+/** Canvas coordinates (pixels). */
+interface AXPWorkflowPoint {
+    x: number;
+    y: number;
+}
+interface AXPWorkflowSize {
+    width: number;
+    height: number;
+}
+/** Axis-aligned rectangle used by routing/obstacle helpers. */
+interface AXPWorkflowRect {
+    position: AXPWorkflowPoint;
+    size: AXPWorkflowSize;
+}
+type AXPWorkflowSemanticColor = Omit<AXStyleColorType, 'default'>;
+type AXPWorkflowPortSide = 'top' | 'right' | 'bottom' | 'left';
+interface AXPWorkflowPort {
+    id: string;
+    /** Inbound accepts incoming connectors; outbound emits connections. */
+    kind: 'inbound' | 'outbound';
+    /** Optional stable key for host logic (e.g. "default", "error"). */
+    key?: string;
+    label?: string;
+    /** Position along the chosen edge, 0–1. */
+    ratio: number;
+    side: AXPWorkflowPortSide;
+    /** When true, multiple connectors may attach (inbound only). */
+    allowMultiple?: boolean;
+    /** When true, port cannot be used for new connections. */
+    disabled?: boolean;
+    /** Per-port readonly: no connect/disconnect interactions. */
+    readonly?: boolean;
+    /** Arbitrary payload (conditions, routing metadata, etc.). */
+    data?: Record<string, unknown>;
+}
+interface AXPWorkflowConnector {
+    id: string;
+    sourceNodeId: string;
+    sourcePortId: string;
+    targetNodeId: string;
+    targetPortId: string;
+    /** Arbitrary payload (conditions, labels, etc.). */
+    data?: Record<string, unknown>;
+    /** Per-connector readonly: cannot delete or reconnect. */
+    readonly?: boolean;
+    /** Theme token applied as `ax-{color}-surface` on the edge stroke styling. */
+    color?: AXPWorkflowSemanticColor;
+}
+type AXPWorkflowNodeShape = 'rectangle' | 'rounded-rectangle' | 'circle' | 'ellipse' | 'diamond';
+interface AXPWorkflowNode {
+    id: string;
+    /** Palette / definition type key. */
+    type: string;
+    title: string;
+    icon?: string;
+    shape: AXPWorkflowNodeShape;
+    position: AXPWorkflowPoint;
+    size: AXPWorkflowSize;
+    inboundPorts: AXPWorkflowPort[];
+    outboundPorts: AXPWorkflowPort[];
+    /** Arbitrary domain payload. */
+    data?: Record<string, unknown>;
+    /** When true, node cannot be moved, resized, or connected. */
+    readonly?: boolean;
+    /** When true, width/height stay proportional while resizing. */
+    lockAspectRatio?: boolean;
+    /**
+     * Snap override: `true` / `false` forces behavior; `undefined` uses designer default.
+     */
+    snapToGrid?: boolean;
+    /** Theme token applied as `ax-{color}-surface` on the node shape. */
+    color?: AXPWorkflowSemanticColor;
+}
+interface AXPWorkflowDiagramModel {
+    nodes: AXPWorkflowNode[];
+    connectors: AXPWorkflowConnector[];
+    /** Optional diagram-level metadata. */
+    data?: Record<string, unknown>;
+}
+/** Flow direction for the arranged diagram. `horizontal` = left→right, `vertical` = top→bottom. */
+type AXPWorkflowArrangeDirection = 'horizontal' | 'vertical';
+/** Cross-axis alignment within a single rank (column for horizontal, row for vertical). */
+type AXPWorkflowArrangeAlignment = 'start' | 'center' | 'end';
+interface AXPWorkflowArrangeDiagramOptions {
+    /** Preferred start node (first column for horizontal, first row for vertical). When omitted, nodes without inbound edges are roots. */
+    startNodeId?: string;
+    /** Snaps arranged positions to this grid (pixels). `0` disables snapping. */
+    gridSize?: number;
+    /** Outer padding around the arranged area. */
+    margin?: number;
+    /** Gap between adjacent columns (horizontal) or rows (vertical). */
+    horizontalGap?: number;
+    /** Gap between siblings within a column (horizontal) or row (vertical). */
+    verticalGap?: number;
+    /** Primary flow direction. Defaults to `'horizontal'`. */
+    direction?: AXPWorkflowArrangeDirection;
+    /** Cross-axis alignment inside each rank. Defaults to `'center'`. */
+    alignment?: AXPWorkflowArrangeAlignment;
+    /** Top-left origin of the arranged area in model coordinates. Defaults to `{ x: margin, y: margin }`. */
+    origin?: AXPWorkflowPoint;
+    /** Only arrange the listed nodes (others keep their current position). */
+    nodeIds?: string[];
+    /** Apply barycenter ordering inside each rank to reduce crossings. Defaults to `true`. */
+    reduceCrossings?: boolean;
+    /** Lay each disconnected component out in its own block, stacked along the cross axis. Defaults to `true`. */
+    groupDisconnected?: boolean;
+}
+interface AXPWorkflowActivityPaletteItem {
+    type: string;
+    title: string;
+    description?: string;
+    icon?: string;
+    shape?: AXPWorkflowNodeShape;
+    size?: AXPWorkflowSize;
+    /** When set (including `[]`), defines inbound ports; when omitted, one default inbound is used. */
+    inboundPorts?: Omit<AXPWorkflowPort, 'id' | 'kind'>[];
+    /** When set (including `[]`), defines outbound ports; when omitted, one default outbound is used. */
+    outboundPorts?: Omit<AXPWorkflowPort, 'id' | 'kind'>[];
+    data?: Record<string, unknown>;
+    lockAspectRatio?: boolean;
+    snapToGrid?: boolean;
+    color?: AXPWorkflowSemanticColor;
+}
+/**
+ * Context passed to `nodeBodyTemplate` (`NgTemplateOutlet`).
+ * Supports `let-n` via `$implicit` or `let-n="node"`.
+ */
+interface AXPWorkflowNodeBodyTemplateContext {
+    $implicit: AXPWorkflowNode;
+    node: AXPWorkflowNode;
+}
+interface AXPWorkflowConnectRequest {
+    sourceNodeId: string;
+    sourcePortId: string;
+    targetNodeId: string;
+    targetPortId: string;
+    model: AXPWorkflowDiagramModel;
+}
+type AXPWorkflowCanConnectFn = (request: AXPWorkflowConnectRequest) => boolean;
+type AXPWorkflowConnectionPreviewStyle = 'straight' | 'rounded' | 'orthogonal';
+/**
+ * Optional routing hints for `connectorPath`. When provided, orthogonal/rounded
+ * paths avoid the supplied obstacle rectangles by detouring around them.
+ */
+interface AXPWorkflowConnectorRouteOptions {
+    /** Inbound port side at the destination. When omitted, the opposite of `sourceSide` is assumed. */
+    targetSide?: AXPWorkflowPortSide;
+    /** Other node rectangles to bypass. Source/target nodes should be excluded. */
+    obstacles?: AXPWorkflowRect[];
+    /** Distance (px) the connector extends straight out of the source/target port before turning. */
+    stub?: number;
+    /** Extra space (px) around each obstacle when planning the route. */
+    obstaclePadding?: number;
+    /** Corner radius (px) used by the `rounded` style. */
+    cornerRadius?: number;
+}
+type AXPWorkflowDesignerActivationKind = 'canvas' | 'node' | 'port' | 'connector';
+interface AXPWorkflowDesignerActivation {
+    kind: AXPWorkflowDesignerActivationKind;
+    /** Node id, port id, or connector id depending on `kind`. */
+    id: string;
+    /** For port activation, parent node id. */
+    nodeId?: string;
+}
+
+interface LinkDragState {
+    sourceNodeId: string;
+    sourcePortId: string;
+    from: AXPWorkflowPoint;
+    to: AXPWorkflowPoint;
+}
+interface ResizeState {
+    nodeId: string;
+    handle: 'nw' | 'ne' | 'sw' | 'se';
+    startPointer: AXPWorkflowPoint;
+    startPosition: AXPWorkflowPoint;
+    startSize: {
+        width: number;
+        height: number;
+    };
+    aspect: number;
+}
+interface CanvasViewportState {
+    minX: number;
+    minY: number;
+    offsetX: number;
+    offsetY: number;
+    width: number;
+    height: number;
+}
+declare class AXPWorkflowDesignerComponent {
+    /** Unique SVG fragment id so multiple designers on one page do not clash. */
+    protected readonly svgMarkerId: string;
+    readonly model: _angular_core.InputSignal<AXPWorkflowDiagramModel>;
+    readonly modelChange: _angular_core.OutputEmitterRef<AXPWorkflowDiagramModel>;
+    /** When true, the whole designer is non-interactive unless a nested entity sets its own readonly flag. */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly gridSize: _angular_core.InputSignal<number>;
+    /** Default snap when node does not override `snapToGrid`. */
+    readonly snapToGrid: _angular_core.InputSignal<boolean>;
+    readonly connectionPreviewStyle: _angular_core.InputSignal<AXPWorkflowConnectionPreviewStyle>;
+    readonly backgroundPattern: _angular_core.InputSignal<"line" | "dots">;
+    readonly zoomChange: _angular_core.OutputEmitterRef<number>;
+    /** When set, replaces built-in `defaultCanConnectRequest` entirely. */
+    readonly canConnect: _angular_core.InputSignal<AXPWorkflowCanConnectFn | null>;
+    /** Used to resolve native palette drag payloads (`type`) into full defaults. */
+    readonly paletteItems: _angular_core.InputSignal<AXPWorkflowActivityPaletteItem[]>;
+    /** When false, port labels are hidden (ports remain interactive). */
+    readonly showPortLabels: _angular_core.InputSignal<boolean>;
+    readonly nodeBodyTemplate: _angular_core.InputSignal<TemplateRef<AXPWorkflowNodeBodyTemplateContext> | null>;
+    readonly designerPointerDown: _angular_core.OutputEmitterRef<PointerEvent>;
+    readonly designerClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    readonly designerDoubleClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    readonly nodePointerDown: _angular_core.OutputEmitterRef<{
+        node: AXPWorkflowNode;
+        event: PointerEvent;
+    }>;
+    readonly nodeClick: _angular_core.OutputEmitterRef<{
+        node: AXPWorkflowNode;
+        event: PointerEvent;
+    }>;
+    readonly nodeDoubleClick: _angular_core.OutputEmitterRef<{
+        node: AXPWorkflowNode;
+        event: MouseEvent;
+    }>;
+    readonly nodeContextMenu: _angular_core.OutputEmitterRef<{
+        node: AXPWorkflowNode;
+        event: MouseEvent;
+    }>;
+    readonly nodeDragStart: _angular_core.OutputEmitterRef<{
+        node: AXPWorkflowNode;
+        event: PointerEvent;
+    }>;
+    readonly nodeDragEnd: _angular_core.OutputEmitterRef<{
+        node: AXPWorkflowNode;
+        event: PointerEvent;
+    }>;
+    readonly portPointerDown: _angular_core.OutputEmitterRef<{
+        node: AXPWorkflowNode;
+        port: AXPWorkflowPort;
+        event: PointerEvent;
+    }>;
+    readonly linkDragStart: _angular_core.OutputEmitterRef<{
+        sourceNode: AXPWorkflowNode;
+        sourcePort: AXPWorkflowPort;
+        event: PointerEvent;
+    }>;
+    readonly linkDragMove: _angular_core.OutputEmitterRef<{
+        sourceNode: AXPWorkflowNode;
+        sourcePort: AXPWorkflowPort;
+        point: AXPWorkflowPoint;
+        event: PointerEvent;
+    }>;
+    readonly linkDragEnd: _angular_core.OutputEmitterRef<{
+        sourceNode: AXPWorkflowNode;
+        sourcePort: AXPWorkflowPort;
+        cancelled: boolean;
+        event: Event;
+    }>;
+    readonly connectorClick: _angular_core.OutputEmitterRef<{
+        connector: AXPWorkflowConnector;
+        event: MouseEvent;
+    }>;
+    readonly connectorDoubleClick: _angular_core.OutputEmitterRef<{
+        connector: AXPWorkflowConnector;
+        event: MouseEvent;
+    }>;
+    readonly connectionCreated: _angular_core.OutputEmitterRef<{
+        connector: AXPWorkflowConnector;
+        model: AXPWorkflowDiagramModel;
+    }>;
+    readonly connectionRejected: _angular_core.OutputEmitterRef<{
+        reason: string;
+        request: AXPWorkflowConnectRequest;
+        event: PointerEvent;
+    }>;
+    readonly activationChange: _angular_core.OutputEmitterRef<AXPWorkflowDesignerActivation | null>;
+    protected readonly surfaceRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    private readonly panViewRef;
+    protected readonly activation: _angular_core.WritableSignal<AXPWorkflowDesignerActivation | null>;
+    protected readonly selectedNodeIds: _angular_core.WritableSignal<Set<string>>;
+    protected readonly selectedConnectorIds: _angular_core.WritableSignal<Set<string>>;
+    protected readonly panX: _angular_core.WritableSignal<number>;
+    protected readonly panY: _angular_core.WritableSignal<number>;
+    protected readonly panZoomLevel: _angular_core.WritableSignal<number>;
+    protected readonly linkDrag: _angular_core.WritableSignal<LinkDragState | null>;
+    /** Inbound port under the pointer while dragging a new connector from an outbound port. */
+    protected readonly linkHoverTarget: _angular_core.WritableSignal<{
+        nodeId: string;
+        portId: string;
+    } | null>;
+    private nodeMove;
+    private resize;
+    private suppressNextNodeClick;
+    private wrapperDragoverListener;
+    private wrapperDropListener;
+    private wrapperElement;
+    private wrapperAttachRetryHandle;
+    private wrapperAttachAttempt;
+    private readonly destroyRef;
+    protected readonly gridStyle: _angular_core.Signal<{
+        'background-size': string;
+        'background-image': string;
+    }>;
+    protected readonly canvasViewport: _angular_core.Signal<CanvasViewportState>;
+    protected readonly surfaceStyle: _angular_core.Signal<{
+        width: string;
+        height: string;
+    }>;
+    constructor();
+    zoomIn(): void;
+    zoomOut(): void;
+    zoomReset(): void;
+    getZoomLevel(): number;
+    protected isNodeReadonly(node: AXPWorkflowNode): boolean;
+    protected isConnectorReadonly(c: AXPWorkflowConnector): boolean;
+    protected isNodeActive(nodeId: string): boolean;
+    protected isConnectorActive(id: string): boolean;
+    protected isPortActive(nodeId: string, portId: string): boolean;
+    protected isPortLinkHoverTarget(nodeId: string, portId: string): boolean;
+    private setActivation;
+    private clearSelections;
+    private commit;
+    /**
+     * Auto-arranges nodes into a layered layout and commits the result.
+     *
+     * Honors layout options such as `direction` (`'horizontal'` / `'vertical'`),
+     * `alignment`, `origin`, `nodeIds` (subset arrange), and `reduceCrossings`.
+     * When `gridSize` is omitted the designer's own `gridSize` input is used.
+     */
+    arrangeNicely(options?: AXPWorkflowArrangeDiagramOptions): void;
+    /**
+     * Computes an arranged layout without committing it. Useful for previews,
+     * comparing the result before applying it, or rendering ghost positions.
+     */
+    computeArrangedLayout(options?: AXPWorkflowArrangeDiagramOptions): AXPWorkflowDiagramModel;
+    private resolvePaletteItem;
+    /**
+     * Full drag payload merged with `paletteItems()` entry when the payload omits optional fields.
+     */
+    private resolveDroppedPaletteItem;
+    private evaluateConnect;
+    protected onSurfacePointerDown(event: PointerEvent): void;
+    protected onSurfaceClick(event: MouseEvent): void;
+    protected onSurfaceDoubleClick(event: MouseEvent): void;
+    private isBackgroundInteractionTarget;
+    protected canvasPointFromClient(clientX: number, clientY: number): AXPWorkflowPoint;
+    protected onCanvasDragOver(event: DragEvent): void;
+    protected onCanvasDrop(event: DragEvent): void;
+    private applySnapToPointForNewNode;
+    private applySnapForNode;
+    private attachWrapperDropTargetsWithRetry;
+    /**
+     * Binds drag/drop to pan-view wrapper so users can drop while panning far away
+     * from current finite surface bounds.
+     */
+    private attachWrapperDropTargets;
+    private detachWrapperDropTargets;
+    private clearWrapperAttachRetry;
+    protected onWindowKeydown(ev: KeyboardEvent): void;
+    private cancelLinkDrag;
+    protected shapeClass(shape: AXPWorkflowNode['shape']): string;
+    protected semanticSurfaceClass(color?: AXPWorkflowSemanticColor): string;
+    protected nodeShapeClasses(node: AXPWorkflowNode): string;
+    protected connectorEdgeClasses(c: AXPWorkflowConnector): string;
+    protected onNodePointerDown(node: AXPWorkflowNode, event: PointerEvent): void;
+    protected onNodeClick(node: AXPWorkflowNode, event: MouseEvent): void;
+    protected onNodeDoubleClick(node: AXPWorkflowNode, event: MouseEvent): void;
+    protected onNodeContextMenu(node: AXPWorkflowNode, event: MouseEvent): void;
+    protected onNodeBodyPointerDown(node: AXPWorkflowNode, event: PointerEvent): void;
+    private readonly onWindowPointerMoveForNode;
+    private readonly onWindowPointerUpForNode;
+    protected onResizePointerDown(node: AXPWorkflowNode, handle: ResizeState['handle'], event: PointerEvent): void;
+    private readonly onWindowPointerMoveForResize;
+    private readonly onWindowPointerUpForResize;
+    protected onPortPointerDown(node: AXPWorkflowNode, port: AXPWorkflowPort, event: PointerEvent): void;
+    private readonly onWindowPointerMoveForLink;
+    private readonly onWindowPointerUpForLink;
+    private pickInboundPortAtPoint;
+    protected connectorPathD(c: AXPWorkflowConnector): string;
+    protected connectorMidpoint(c: AXPWorkflowConnector): AXPWorkflowPoint;
+    protected onConnectorClick(c: AXPWorkflowConnector, event: MouseEvent): void;
+    protected onConnectorDoubleClick(c: AXPWorkflowConnector, event: MouseEvent): void;
+    protected removeConnector(c: AXPWorkflowConnector): void;
+    protected previewPath(): string;
+    protected templateContext(node: AXPWorkflowNode): AXPWorkflowNodeBodyTemplateContext;
+    protected portClusterStyle(node: AXPWorkflowNode, port: AXPWorkflowPort): Record<string, string>;
+    protected portLabelText(port: AXPWorkflowPort): string;
+    protected portLabelX(node: AXPWorkflowNode, port: AXPWorkflowPort): number;
+    protected portLabelY(node: AXPWorkflowNode, port: AXPWorkflowPort): number;
+    protected portLabelAnchor(node: AXPWorkflowNode, port: AXPWorkflowPort): 'start' | 'middle' | 'end';
+    protected nodeSurfaceLeft(node: AXPWorkflowNode): number;
+    protected nodeSurfaceTop(node: AXPWorkflowNode): number;
+    private trimmedConnectorTarget;
+    private portLabelCanvasPoint;
+    private modelPointToSurface;
+    private surfacePointToModel;
+    /**
+     * Returns node bounding boxes in surface coordinates.
+     *
+     * All nodes are returned so the router can route AROUND every node, including
+     * the source and target of a connector. The router itself drops obstacles that
+     * already contain the stub-out point so the connector can still exit/enter its port.
+     */
+    private collectObstaclesInSurface;
+    private syncWrapperBackgroundStyle;
+    private detachWindowListeners;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWorkflowDesignerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWorkflowDesignerComponent, "axp-workflow-designer", never, { "model": { "alias": "model"; "required": true; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "gridSize": { "alias": "gridSize"; "required": false; "isSignal": true; }; "snapToGrid": { "alias": "snapToGrid"; "required": false; "isSignal": true; }; "connectionPreviewStyle": { "alias": "connectionPreviewStyle"; "required": false; "isSignal": true; }; "backgroundPattern": { "alias": "backgroundPattern"; "required": false; "isSignal": true; }; "canConnect": { "alias": "canConnect"; "required": false; "isSignal": true; }; "paletteItems": { "alias": "paletteItems"; "required": false; "isSignal": true; }; "showPortLabels": { "alias": "showPortLabels"; "required": false; "isSignal": true; }; "nodeBodyTemplate": { "alias": "nodeBodyTemplate"; "required": false; "isSignal": true; }; }, { "modelChange": "modelChange"; "zoomChange": "zoomChange"; "designerPointerDown": "designerPointerDown"; "designerClick": "designerClick"; "designerDoubleClick": "designerDoubleClick"; "nodePointerDown": "nodePointerDown"; "nodeClick": "nodeClick"; "nodeDoubleClick": "nodeDoubleClick"; "nodeContextMenu": "nodeContextMenu"; "nodeDragStart": "nodeDragStart"; "nodeDragEnd": "nodeDragEnd"; "portPointerDown": "portPointerDown"; "linkDragStart": "linkDragStart"; "linkDragMove": "linkDragMove"; "linkDragEnd": "linkDragEnd"; "connectorClick": "connectorClick"; "connectorDoubleClick": "connectorDoubleClick"; "connectionCreated": "connectionCreated"; "connectionRejected": "connectionRejected"; "activationChange": "activationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Makes any host element a draggable palette source. Set `[axpWorkflowPaletteItem]="item"` and optional outputs.
+ * Drop target: `axp-workflow-designer` canvas (same MIME as drag payload).
+ */
+declare class AXPWorkflowPaletteItemDragDirective {
+    /** Palette definition serialized into the drag payload. */
+    readonly axpWorkflowPaletteItem: _angular_core.InputSignal<AXPWorkflowActivityPaletteItem>;
+    /** When true, drag is disabled. */
+    readonly axpWorkflowPaletteDragDisabled: _angular_core.InputSignal<boolean>;
+    readonly axpWorkflowPaletteDragStart: _angular_core.OutputEmitterRef<{
+        item: AXPWorkflowActivityPaletteItem;
+        event: DragEvent;
+    }>;
+    readonly axpWorkflowPaletteDragEnd: _angular_core.OutputEmitterRef<{
+        item: AXPWorkflowActivityPaletteItem | null;
+        event: DragEvent;
+    }>;
+    protected readonly hostDraggable: _angular_core.Signal<true | null>;
+    private lastItem;
+    protected onDragStart(event: DragEvent): void;
+    protected onDragEnd(event: DragEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWorkflowPaletteItemDragDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXPWorkflowPaletteItemDragDirective, "[axpWorkflowPaletteItem]", never, { "axpWorkflowPaletteItem": { "alias": "axpWorkflowPaletteItem"; "required": true; "isSignal": true; }; "axpWorkflowPaletteDragDisabled": { "alias": "axpWorkflowPaletteDragDisabled"; "required": false; "isSignal": true; }; }, { "axpWorkflowPaletteDragStart": "axpWorkflowPaletteDragStart"; "axpWorkflowPaletteDragEnd": "axpWorkflowPaletteDragEnd"; }, never, never, true, never>;
+}
+
+/** MIME type for native drag payloads carrying `AXPWorkflowActivityPaletteItem` JSON. */
+declare const AXP_WORKFLOW_PALETTE_MIME = "application/x-axp-workflow-palette-item";
+
+declare function createWorkflowNodeId(): string;
+declare function createWorkflowConnectorId(): string;
+declare function createWorkflowPortId(prefix: string): string;
+declare function cloneDiagram(model: AXPWorkflowDiagramModel): AXPWorkflowDiagramModel;
+declare function createPortsFromPalette(nodeId: string, item: AXPWorkflowActivityPaletteItem): {
+    inbound: AXPWorkflowPort[];
+    outbound: AXPWorkflowPort[];
+};
+declare function createNodeFromPaletteItem(item: AXPWorkflowActivityPaletteItem, position: AXPWorkflowPoint): AXPWorkflowNode;
+/**
+ * Parses drag `dataTransfer` JSON into a partial palette item (requires `type`).
+ * Merge with catalog (`paletteItems`) to obtain `title` and defaults.
+ */
+declare function parsePaletteItemDragPayload(raw: string | undefined): (Partial<AXPWorkflowActivityPaletteItem> & {
+    type: string;
+}) | null;
+declare function snapScalar(value: number, grid: number): number;
+declare function snapPoint(point: AXPWorkflowPoint, grid: number): AXPWorkflowPoint;
+declare function portAnchorOnNode(node: AXPWorkflowNode, port: AXPWorkflowPort): AXPWorkflowPoint;
+declare function portCanvasPosition(node: AXPWorkflowNode, port: AXPWorkflowPort): AXPWorkflowPoint;
+/**
+ * Routes an obstacle-aware orthogonal path between two free-space points.
+ * The returned array includes the start (`from`), stub-outs from each port,
+ * intermediate waypoints, and the end (`to`).
+ *
+ * Obstacles whose inflated rect already contains a stub point are dropped so
+ * that source/target nodes can still emit/receive their connector without the
+ * router fighting itself — but the middle of the path still routes around them.
+ */
+declare function routeOrthogonalConnector(from: AXPWorkflowPoint, sourceSide: AXPWorkflowPortSide, to: AXPWorkflowPoint, targetSide: AXPWorkflowPortSide, obstacles?: AXPWorkflowRect[], options?: {
+    stub?: number;
+    obstaclePadding?: number;
+}): AXPWorkflowPoint[];
+/**
+ * Builds the SVG `d` string for a connector. When `options.obstacles` is supplied,
+ * orthogonal/rounded routes detour around the obstacle rectangles instead of
+ * passing through them. The `straight` style always draws a direct line.
+ */
+declare function connectorPath(from: AXPWorkflowPoint, to: AXPWorkflowPoint, style: AXPWorkflowConnectionPreviewStyle, sourceSide: AXPWorkflowPortSide, options?: AXPWorkflowConnectorRouteOptions): string;
+declare function findNode(model: AXPWorkflowDiagramModel, nodeId: string): AXPWorkflowNode | undefined;
+declare function findPort(node: AXPWorkflowNode, portId: string): {
+    port: AXPWorkflowPort;
+    inbound: boolean;
+} | undefined;
+declare function findConnector(model: AXPWorkflowDiagramModel, id: string): AXPWorkflowConnector | undefined;
+/**
+ * Built-in rules: valid ports, not disabled, optional single inbound attachment, no duplicate edge.
+ */
+declare function defaultCanConnectRequest(request: AXPWorkflowConnectRequest): boolean;
+/**
+ * Auto-arranges workflow nodes in a layered layout (left→right by default).
+ * Honors `direction`, `alignment`, `origin`, `nodeIds`, and crossing-reduction options.
+ */
+declare function arrangeWorkflowDiagram(model: AXPWorkflowDiagramModel, options?: AXPWorkflowArrangeDiagramOptions): AXPWorkflowDiagramModel;
+
+export { AXMPlatformManagementModule, AXMTokenEntityModule, AXMTokensService, AXMTokensServiceImpl, AXPPlatformManagementFeatureKeys, AXPWorkflowDesignerComponent, AXPWorkflowPaletteItemDragDirective, AXP_WORKFLOW_PALETTE_MIME, RootConfig, aggregateDefinitionEntityFactory, arrangeWorkflowDiagram, cloneDiagram, commandDefinitionEntityFactory, connectorPath, createNodeFromPaletteItem, createPortsFromPalette, createWorkflowConnectorId, createWorkflowNodeId, createWorkflowPortId, defaultCanConnectRequest, findConnector, findNode, findPort, interfaceDefinitionEntityFactory, interfaceDefinitionFromWidgetFieldConfiguratorValue, mapEntityFieldRowsInterfaceForForm, mapEntityFieldRowsInterfaceToDomain, menuDefinitionEntityFactory, moduleDefinitionEntityFactory, parsePaletteItemDragPayload, permissionGroupDefinitionEntityFactory, pluginDefinitionEntityFactory, portAnchorOnNode, portCanvasPosition, queryDefinitionEntityFactory, relationDefinitionEntityFactory, routeOrthogonalConnector, snapPoint, snapScalar, toWidgetFieldConfiguratorColumnNode, tokenEntityFactory, validationDefinitionEntityFactory, widgetFieldConfiguratorValueFromInterfaceDefinition };
+export type { AXMEntityDefinitionEntityModel, AXMTokenDataType, AXMTokenEntityModel, AXMTokenFormat, AXMTokenKind, AXPWorkflowActivityPaletteItem, AXPWorkflowArrangeAlignment, AXPWorkflowArrangeDiagramOptions, AXPWorkflowArrangeDirection, AXPWorkflowCanConnectFn, AXPWorkflowConnectRequest, AXPWorkflowConnectionPreviewStyle, AXPWorkflowConnector, AXPWorkflowConnectorRouteOptions, AXPWorkflowDesignerActivation, AXPWorkflowDesignerActivationKind, AXPWorkflowDiagramModel, AXPWorkflowNode, AXPWorkflowNodeBodyTemplateContext, AXPWorkflowNodeShape, AXPWorkflowPoint, AXPWorkflowPort, AXPWorkflowPortSide, AXPWorkflowRect, AXPWorkflowSemanticColor, AXPWorkflowSize, SchemaInterfaceFormValue };