@foblex/flow 17.8.0 → 17.8.2

package/f-connection/providers.d.ts

@@ -1,7 +1,7 @@
-import { FConnectionGradientComponent, FConnectionPathComponent, FConnectionSelectionComponent, FConnectionTextComponent, FConnectionTextPathDirective } from './common';
+import { FConnectionDragHandleEndComponent, FConnectionDragHandleStartComponent, FConnectionGradientComponent, FConnectionPathComponent, FConnectionSelectionComponent, FConnectionTextComponent, FConnectionTextPathDirective } from './common';
 import { FConnectionComponent } from './f-connection';
 import { FConnectionCenterDirective } from './f-connection-center';
 import { FConnectionForCreateComponent } from './f-connection-for-create';
 import { FMarkerDirective } from './f-marker';
 import { FSnapConnectionComponent } from './f-snap-connection';
-export declare const F_CONNECTION_PROVIDERS: (typeof FConnectionTextPathDirective | typeof FConnectionTextComponent | typeof FConnectionGradientComponent | typeof FConnectionPathComponent | typeof FConnectionSelectionComponent | typeof FConnectionCenterDirective | typeof FConnectionForCreateComponent | typeof FConnectionComponent | typeof FMarkerDirective | typeof FSnapConnectionComponent)[];
+export declare const F_CONNECTION_PROVIDERS: (typeof FConnectionDragHandleStartComponent | typeof FConnectionDragHandleEndComponent | typeof FConnectionSelectionComponent | typeof FConnectionCenterDirective | typeof FConnectionTextPathDirective | typeof FConnectionTextComponent | typeof FConnectionGradientComponent | typeof FConnectionPathComponent | typeof FConnectionForCreateComponent | typeof FConnectionComponent | typeof FMarkerDirective | typeof FSnapConnectionComponent)[];

package/f-connectors/f-connector-base.d.ts

@@ -1,9 +1,10 @@
 import { EFConnectableSide } from './e-f-connectable-side';
 import { IHasHostElement } from '../i-has-host-element';
+import { Signal } from '@angular/core';
 export declare abstract class FConnectorBase implements IHasHostElement {
-    abstract fId: string;
+    abstract fId: Signal<string>;
     abstract fNodeId: string;
-    abstract disabled: boolean;
+    abstract disabled: Signal<boolean>;
     abstract hostElement: HTMLElement | SVGElement;
     abstract canBeConnected: boolean;
     private _isConnected;

package/f-connectors/f-node-input/f-node-input-base.d.ts

@@ -1,9 +1,10 @@
-import { InjectionToken } from '@angular/core';
+import { InjectionToken, Signal } from '@angular/core';
 import { FConnectorBase } from '../f-connector-base';
 import * as i0 from "@angular/core";
 export declare const F_NODE_INPUT: InjectionToken<FNodeInputBase>;
 export declare abstract class FNodeInputBase extends FConnectorBase {
-    abstract multiple: boolean;
+    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, false, never>;

package/f-connectors/f-node-input/f-node-input.directive.d.ts

@@ -4,22 +4,21 @@ import { EFConnectableSide } from '../e-f-connectable-side';
 import { FConnectorBase } from '../f-connector-base';
 import * as i0 from "@angular/core";
 export declare class FNodeInputDirective extends FNodeInputBase implements OnInit, OnChanges, OnDestroy {
-    private _elementReference;
-    private _fMediator;
-    private _fNode;
-    fId: any;
-    multiple: boolean;
-    disabled: boolean;
+    readonly hostElement: any;
+    private readonly _mediator;
+    private readonly _node;
+    fId: import("@angular/core").InputSignalWithTransform<string, unknown>;
+    category: import("@angular/core").InputSignalWithTransform<string | undefined, unknown>;
+    multiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     userFConnectableSide: EFConnectableSide;
     get fNodeId(): string;
-    get hostElement(): 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; }; "multiple": { "alias": "fInputMultiple"; "required": false; }; "disabled": { "alias": "fInputDisabled"; "required": false; }; "userFConnectableSide": { "alias": "fInputConnectableSide"; "required": false; }; }, {}, never, never, false, never>;
-    static ngAcceptInputType_disabled: unknown;
+    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;
 }

package/f-connectors/f-node-outlet/f-node-outlet-base.d.ts

@@ -1,12 +1,12 @@
 import { InjectionToken } from '@angular/core';
 import { FConnectorBase } from '../f-connector-base';
+import { FSourceConnectorBase } from '../f-source-connector-base';
 import * as i0 from "@angular/core";
 export declare const F_NODE_OUTLET: InjectionToken<FNodeOutletBase>;
-export declare abstract class FNodeOutletBase extends FConnectorBase {
+export declare abstract class FNodeOutletBase extends FSourceConnectorBase {
     abstract isConnectionFromOutlet: boolean;
-    private outputs;
+    private _outputs;
     get canBeConnected(): boolean;
-    abstract canBeConnectedInputs: string[];
     setOutputs(outputs: FConnectorBase[]): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutletBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletBase, never, never, {}, {}, never, never, false, never>;

package/f-connectors/f-node-outlet/f-node-outlet.directive.d.ts

@@ -3,20 +3,18 @@ import { FNodeOutletBase } from './f-node-outlet-base';
 import { EFConnectableSide } from '../e-f-connectable-side';
 import * as i0 from "@angular/core";
 export declare class FNodeOutletDirective extends FNodeOutletBase implements OnInit, OnDestroy {
-    private _elementReference;
-    private _fMediator;
-    private _fNode;
-    fId: string;
-    disabled: boolean;
+    readonly hostElement: any;
+    private readonly _mediator;
+    private readonly _node;
+    fId: import("@angular/core").InputSignalWithTransform<string, unknown>;
+    disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     fConnectableSide: EFConnectableSide;
     userFConnectableSide: EFConnectableSide;
     isConnectionFromOutlet: boolean;
     canBeConnectedInputs: string[];
     get fNodeId(): string;
-    get hostElement(): HTMLElement | SVGElement;
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutletDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletDirective, "[fNodeOutlet]", ["fNodeOutlet"], { "fId": { "alias": "fOutletId"; "required": false; }; "disabled": { "alias": "fOutletDisabled"; "required": false; }; "isConnectionFromOutlet": { "alias": "isConnectionFromOutlet"; "required": false; }; "canBeConnectedInputs": { "alias": "fCanBeConnectedInputs"; "required": false; }; }, {}, never, never, false, never>;
-    static ngAcceptInputType_disabled: unknown;
+    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>;
 }

package/f-connectors/f-node-output/f-node-output-base.d.ts

@@ -1,11 +1,10 @@
-import { InjectionToken } from '@angular/core';
-import { FConnectorBase } from '../f-connector-base';
+import { InjectionToken, Signal } from '@angular/core';
+import { FSourceConnectorBase } from '../f-source-connector-base';
 import * as i0 from "@angular/core";
 export declare const F_NODE_OUTPUT: InjectionToken<FNodeOutputBase>;
-export declare abstract class FNodeOutputBase extends FConnectorBase {
-    abstract multiple: boolean;
+export declare abstract class FNodeOutputBase extends FSourceConnectorBase {
+    abstract multiple: Signal<boolean>;
     get canBeConnected(): boolean;
-    abstract canBeConnectedInputs: string[];
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutputBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputBase, never, never, {}, {}, never, never, false, never>;
 }

package/f-connectors/f-node-output/f-node-output.directive.d.ts

@@ -4,24 +4,22 @@ import { EFConnectableSide } from '../e-f-connectable-side';
 import { FConnectorBase } from '../f-connector-base';
 import * as i0 from "@angular/core";
 export declare class FNodeOutputDirective extends FNodeOutputBase implements OnInit, OnChanges, OnDestroy {
-    private _elementReference;
-    private _fMediator;
-    private _fNode;
-    fId: string;
-    multiple: boolean;
-    disabled: boolean;
+    readonly hostElement: any;
+    private readonly _mediator;
+    private readonly _node;
+    fId: import("@angular/core").InputSignalWithTransform<string, unknown>;
+    multiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     userFConnectableSide: EFConnectableSide;
     isSelfConnectable: boolean;
     canBeConnectedInputs: string[];
     get fNodeId(): string;
-    get hostElement(): 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; }; "multiple": { "alias": "fOutputMultiple"; "required": false; }; "disabled": { "alias": "fOutputDisabled"; "required": false; }; "userFConnectableSide": { "alias": "fOutputConnectableSide"; "required": false; }; "isSelfConnectable": { "alias": "isSelfConnectable"; "required": false; }; "canBeConnectedInputs": { "alias": "fCanBeConnectedInputs"; "required": false; }; }, {}, never, never, false, never>;
-    static ngAcceptInputType_disabled: unknown;
+    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;
 }

package/f-connectors/f-source-connector-base.d.ts

@@ -0,0 +1,7 @@
+import { FConnectorBase } from './f-connector-base';
+import { FNodeInputBase } from './f-node-input';
+export declare abstract class FSourceConnectorBase extends FConnectorBase {
+    abstract canBeConnectedInputs: string[];
+    get hasConnectionLimits(): boolean;
+    canConnectTo(targetConnector: FNodeInputBase): boolean;
+}

package/f-connectors/index.d.ts

@@ -2,5 +2,6 @@ export * from './f-node-input';
 export * from './f-node-outlet';
 export * from './f-node-output';
 export * from './f-connector-base';
+export * from './f-source-connector-base';
 export * from './e-f-connectable-side';
 export * from './providers';

package/f-draggable/domain/is-connection-under-node/is-connection-under-node.execution.d.ts

@@ -2,7 +2,7 @@ import { IExecution } from '@foblex/mediator';
 import { IsConnectionUnderNodeRequest } from './is-connection-under-node.request';
 import * as i0 from "@angular/core";
 export declare class IsConnectionUnderNodeExecution implements IExecution<IsConnectionUnderNodeRequest, void> {
-    private readonly _fMediator;
+    private readonly _mediator;
     private readonly _store;
     handle(request: IsConnectionUnderNodeRequest): void;
     private _getOutputConnectors;

package/f-draggable/f-canvas/move-finalize/f-canvas-move-finalize.execution.d.ts

@@ -2,8 +2,8 @@ import { FCanvasMoveFinalizeRequest } from './f-canvas-move-finalize.request';
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FCanvasMoveFinalizeExecution implements IExecution<FCanvasMoveFinalizeRequest, void> {
-    private _dragContext;
-    handle(request: FCanvasMoveFinalizeRequest): void;
+    private readonly _dragContext;
+    handle(_request: FCanvasMoveFinalizeRequest): void;
     private _isValid;
     static ɵfac: i0.ɵɵFactoryDeclaration<FCanvasMoveFinalizeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FCanvasMoveFinalizeExecution>;

package/f-draggable/f-connection/f-create-connection/create-finalize/f-create-connection-finalize.execution.d.ts

@@ -2,17 +2,17 @@ import { IHandler } from '@foblex/mediator';
 import { FCreateConnectionFinalizeRequest } from './f-create-connection-finalize.request';
 import * as i0 from "@angular/core";
 export declare class FCreateConnectionFinalizeExecution implements IHandler<FCreateConnectionFinalizeRequest, void> {
-    private _fResult;
-    private _fMediator;
-    private _store;
-    private _dragContext;
-    private get _fDragHandler();
+    private readonly _result;
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    private get _dragHandler();
     handle(request: FCreateConnectionFinalizeRequest): void;
     private _isValid;
-    private getTargetOutput;
-    private getOutput;
-    private getOutlet;
-    private emitEvent;
+    private _getTargetOutput;
+    private _getOutput;
+    private _getOutlet;
+    private _emitEvent;
     private _getInputUnderPointer;
     static ɵfac: i0.ɵɵFactoryDeclaration<FCreateConnectionFinalizeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FCreateConnectionFinalizeExecution>;

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

@@ -5,13 +5,13 @@ import { Injector } from '@angular/core';
 export declare class FCreateConnectionDragHandler implements IFDragHandler {
     private _fOutputOrOutlet;
     fEventType: string;
-    fData: any;
-    private readonly _fResult;
-    private readonly _fMediator;
+    fData: unknown;
+    private readonly _result;
+    private readonly _mediator;
     private readonly _store;
     private readonly _toConnectorRect;
-    private get _fConnection();
-    private get _fSnapConnection();
+    private get _connection();
+    private get _snapConnection();
     private _fOutputWithRect;
     private _canBeConnectedInputs;
     constructor(_injector: Injector, _fOutputOrOutlet: FNodeOutputBase | FNodeOutletBase, _onPointerDownPosition: IPoint);

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

@@ -6,11 +6,11 @@ export declare class FReassignConnectionDragHandler implements IFDragHandler {
     private _connection;
     private _isTargetDragHandle;
     fEventType: string;
-    fData: any;
-    private readonly _fResult;
-    private readonly _fMediator;
+    fData: unknown;
+    private readonly _result;
+    private readonly _mediator;
     private readonly _store;
-    private get _fSnapConnection();
+    private get _snapConnection();
     private get _sourceConnector();
     private get _targetConnector();
     private get _sourceConnectorAndRect();

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

@@ -1,8 +1,8 @@
-import { FMediator } from "@foblex/mediator";
-import { IConnectorAndRect } from "../../../domain";
-import { FConnectionBase, FSnapConnectionComponent } from "../../../f-connection";
-import { IPoint } from "@foblex/2d";
-import { IFReassignHandler } from "./i-f-reassign-handler";
+import { FMediator } from '@foblex/mediator';
+import { IConnectorAndRect } from '../../../domain';
+import { FConnectionBase, FSnapConnectionComponent } from '../../../f-connection';
+import { IPoint } from '@foblex/2d';
+import { IFReassignHandler } from './i-f-reassign-handler';
 export declare class FReassignSourceDragHandler implements IFReassignHandler {
     private readonly _mediator;
     private readonly _connection;

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

@@ -1,8 +1,8 @@
-import { FMediator } from "@foblex/mediator";
-import { IConnectorAndRect } from "../../../domain";
-import { FConnectionBase, FSnapConnectionComponent } from "../../../f-connection";
-import { IPoint } from "@foblex/2d";
-import { IFReassignHandler } from "./i-f-reassign-handler";
+import { FMediator } from '@foblex/mediator';
+import { IConnectorAndRect } from '../../../domain';
+import { FConnectionBase, FSnapConnectionComponent } from '../../../f-connection';
+import { IPoint } from '@foblex/2d';
+import { IFReassignHandler } from './i-f-reassign-handler';
 export declare class FReassignTargetDragHandler implements IFReassignHandler {
     private readonly _mediator;
     private readonly _connection;

package/f-draggable/f-draggable-base.d.ts

@@ -20,5 +20,5 @@ export declare abstract class FDraggableBase extends DragAndDropBase {
     abstract fCellSizeWhileDragging: InputSignalWithTransform<boolean, unknown>;
     abstract fDragStarted: EventEmitter<FDragStartedEvent>;
     abstract fDragEnded: EventEmitter<void>;
-    protected constructor(ngZone: ICanRunOutsideAngular | undefined);
+    protected constructor(ngZone: ICanRunOutsideAngular | null);
 }

package/f-draggable/f-draggable.directive.d.ts

@@ -7,16 +7,15 @@ import { FEventTrigger } from '../domain';
 import { FCreateNodeEvent } from '../f-external-item';
 import { FDragStartedEvent, FNodeIntersectedWithConnections } from './domain';
 import { FDropToGroupEvent } from './f-drop-to-group';
-import { ICanRunOutsideAngular, IPointerEvent } from '../drag-toolkit';
+import { IPointerEvent } from '../drag-toolkit';
 import * as i0 from "@angular/core";
 export declare class FDraggableDirective extends FDraggableBase implements OnInit, AfterViewInit, OnDestroy {
-    private readonly _elementReference;
-    private readonly _fResult;
+    readonly hostElement: any;
+    private readonly _result;
     private readonly _mediator;
     private readonly _platform;
     private readonly _browser;
     disabled: boolean;
-    get hostElement(): HTMLElement;
     fMultiSelectTrigger: FEventTrigger;
     fReassignConnectionTrigger: FEventTrigger;
     fCreateConnectionTrigger: FEventTrigger;
@@ -55,7 +54,7 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     fDragEnded: EventEmitter<void>;
     private _beforePlugins;
     private _afterPlugins;
-    constructor(ngZone: ICanRunOutsideAngular);
+    constructor();
     ngOnInit(): void;
     ngAfterViewInit(): void;
     onPointerDown(event: IPointerEvent): boolean;
@@ -65,7 +64,7 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     onPointerUp(event: IPointerEvent): void;
     protected finalizeDragSequence(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDirective, [{ optional: true; }]>;
+    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; }; "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"; "fCreateNode": "fCreateNode"; "fMoveNodes": "fMoveNodes"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; "fDropToGroup": "fDropToGroup"; "fDragStarted": "fDragStarted"; "fDragEnded": "fDragEnded"; }, ["_beforePlugins", "_afterPlugins"], never, false, never>;
     static ngAcceptInputType_disabled: unknown;
     static ngAcceptInputType_fEmitOnNodeIntersect: unknown;

package/f-draggable/f-node-rotate/rotate-preparation/f-node-rotate-preparation.execution.d.ts

@@ -2,7 +2,7 @@ import { FNodeRotatePreparationRequest } from './f-node-rotate-preparation.reque
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FNodeRotatePreparationExecution implements IExecution<FNodeRotatePreparationRequest, void> {
-    private readonly _fMediator;
+    private readonly _mediator;
     private readonly _store;
     private readonly _dragContext;
     private readonly _injector;

package/f-node/f-node.directive.d.ts

@@ -6,7 +6,7 @@ import * as i0 from "@angular/core";
 export declare class FNodeDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {
     private readonly _destroyRef;
     private readonly _mediator;
-    readonly fId: import("@angular/core").InputSignal<string>;
+    readonly fId: import("@angular/core").InputSignalWithTransform<string, unknown>;
     readonly fParentId: import("@angular/core").InputSignal<string | null | undefined>;
     readonly position: import("@angular/core").ModelSignal<import("@foblex/2d").IPoint>;
     readonly size: import("@angular/core").InputSignal<ISize | undefined>;