@kortexya/nodus 0.1.0

package/types/internals/Quadtree.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Quadtree spatial index implementation.
+ *
+ * A quadtree recursively partitions 2D space into four quadrants,
+ * supporting fast spatial queries (point, range) and overlap detection.
+ */
+export declare class SpatialIndex {
+    _intersects: ((id: number, minX: number, minY: number, maxX: number, maxY: number) => boolean) | null;
+    _getBounds: ((id: number) => [number, number, number, number]) | null;
+    constructor();
+    setBoundsGetter(fn: (id: number) => [number, number, number, number]): this;
+    setIntersector(fn: (id: number, minX: number, minY: number, maxX: number, maxY: number) => boolean): this;
+}
+export interface QuadtreeNode {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    leaf: boolean;
+    level: number;
+    parent: QuadtreeNode | null;
+    objects: number[] | null;
+    final: boolean;
+    children: QuadtreeNode[] | null;
+}
+/** Returns [minX, minY, maxX, maxY] for a node. */
+export declare function getNodeBBox(node: QuadtreeNode): [number, number, number, number];
+/** Checks if rect (minX,minY)-(maxX,maxY) intersects with bounds. */
+export declare function intersects2(minX1: number, minY1: number, maxX1: number, maxY1: number, minX2: number, minY2: number, maxX2: number, maxY2: number): boolean;
+/** Checks if two axis-aligned bounding boxes overlap. */
+export declare function overlaps(minX1: number, minY1: number, maxX1: number, maxY1: number, minX2: number, minY2: number, maxX2: number, maxY2: number): boolean;
+/** Checks if rect1 is entirely inside rect2. */
+export declare function inside2(minX1: number, minY1: number, maxX1: number, maxY1: number, minX2: number, minY2: number, maxX2: number, maxY2: number): boolean;
+type BoundsGetter = (id: number) => [number, number, number, number];
+/**
+ * Quadtree spatial index for efficient 2D spatial queries.
+ *
+ * Supports insertion, removal, point queries, range queries, overlap detection,
+ * and traversal. Automatically expands the root to accommodate new objects
+ * outside the current bounds.
+ */
+export declare class Quadtree extends SpatialIndex {
+    private _nodeCapacity;
+    private _root;
+    private _objects;
+    private _size;
+    private _rootLevel;
+    private _maxLevel;
+    private _idToCell;
+    /** Creates a flat-array accessor: given stride, returns a function that slices a row. */
+    static flatAccessor: (array: number[] | Float32Array, stride: number) => (index: number) => [number, number, number, number];
+    static inside: typeof inside2;
+    static intersects: typeof intersects2;
+    static overlaps: typeof overlaps;
+    static getNodeBBox: typeof getNodeBBox;
+    constructor(getBounds?: BoundsGetter, nodeCapacity?: number, initialBounds?: [number, number, number, number], rootLevel?: number);
+    get size(): number;
+    get root(): QuadtreeNode | null;
+    /** Removes all objects and resets the tree. */
+    clear(): this;
+    /**
+     * Inserts an object into the quadtree.
+     * If bounds are not provided, they are computed via the bounds getter.
+     */
+    insert(id: number, minX?: number, minY?: number, maxX?: number, maxY?: number, startNode?: QuadtreeNode | null): number | undefined;
+    /** Removes an object by its ID (no bounds lookup needed). */
+    removeById(id: number): number;
+    /** Removes an object using its bounds to locate it in the tree. */
+    remove(id: number): number;
+    /** Splits a leaf node into four children, redistributing its objects. */
+    splitNode(node: QuadtreeNode): void;
+    /** Finds objects at a specific point. If `returnCell` is true, returns all objects in the cell. */
+    point(x: number, y: number, returnCell?: boolean): number[] | null;
+    /** Returns all objects in the cell containing the given point. */
+    neigbours(x: number, y: number): number[];
+    /** Returns all objects whose bounds overlap the given rectangle. */
+    query(minX: number, minY: number, maxX: number, maxY: number): number[];
+    /**
+     * Traverses nodes overlapping the given rectangle, calling `callback` for each matching object.
+     * Stops early if `callback` returns true.
+     */
+    traverse(minX: number, minY: number, maxX: number, maxY: number, callback: (id: number) => boolean): number[];
+    /** Finds all pairs of objects whose bounds overlap. Returns a flat array: [id1, id2, id3, id4, ...]. */
+    getOverlaps(): number[];
+    /** Expands the root to cover the given rectangle. */
+    cover(minX: number, minY: number, maxX: number, maxY: number): this;
+    /** Returns all object IDs in the tree. */
+    getAll(): number[];
+    /** Iterates over all objects in the tree. */
+    forEach(callback: (id: number) => void, thisArg?: unknown): this;
+    /** Returns all leaf nodes. */
+    getLeafs(): QuadtreeNode[];
+    /** Traverses from the root, calling `callback(node, objects)` for each node. Stops descending when callback returns truthy. */
+    traverseFromRoot(callback: (node: QuadtreeNode, objects: number[] | null) => boolean, thisArg?: unknown): this;
+    /** Removes and re-inserts an object with new bounds. */
+    update(id: number, minX?: number, minY?: number, maxX?: number, maxY?: number): this;
+    /** Gets the bounding box of a node. */
+    getNodeBounds(node: QuadtreeNode): [number, number, number, number];
+}
+export default Quadtree;

package/types/internals/RectangleSelect.d.ts

@@ -0,0 +1,18 @@
+import { Lasso } from './Lasso';
+import { BoundingBox } from '../geometry';
+export declare class RectangleSelect extends Lasso {
+    private _rectangle;
+    private _start;
+    protected _onStart: ({ x: e, y: t }: any) => void;
+    protected _onStop: () => void;
+    onMounted(): void;
+    enable(e?: any): this;
+    _formatRectangle(e: {
+        x: number;
+        y: number;
+    }): BoundingBox;
+    _refreshRectangle(e: {
+        x: number;
+        y: number;
+    }): void;
+}

package/types/internals/Resizing.d.ts

@@ -0,0 +1,48 @@
+import { Module } from './Module';
+declare const DEFAULT_OPTIONS9: {
+    color: string;
+    lineWidth: number;
+    handleSize: number;
+    detectionMargin: number;
+    cursor: string;
+    previewColor: string;
+    nbNodesToSnapTo: number;
+    snappingRatio: number;
+    sizeIndicatorColor: string;
+    sizeIndicatorThickness: number;
+    sizeIndicatorOffset: number;
+    sizeIndicatorWidth: number;
+};
+type ResizingOptions = typeof DEFAULT_OPTIONS9;
+export declare class Resizing extends Module {
+    private _enabled;
+    private _nodesToHighlight;
+    private _cursorEnabled;
+    private _x;
+    private _y;
+    private _additionalRadiuses;
+    private _layer;
+    private _engine;
+    private _options;
+    private _nodeBeingResized;
+    private _pointedNode;
+    private _onSelectionChange;
+    private _displayHandlesHandler;
+    private _moveHandler;
+    onMounted(): void;
+    onReady(): void;
+    private _enableCursor;
+    private _disableCursor;
+    private _detectBoundingBoxes;
+    private _forEachNodeToHighlight;
+    private _displayHandles;
+    private _displayNodePreview;
+    private _getTotalRadius;
+    private _snap;
+    private _displaySizeIndicator;
+    enable(options?: Partial<ResizingOptions>): void;
+    disable(): void;
+    private _reset;
+    enabled(): boolean;
+}
+export {};

package/types/internals/Rewiring.d.ts

@@ -0,0 +1,64 @@
+import { Module } from './Module';
+declare const DEFAULT_OPTIONS8: {
+    color: string;
+    radius: number;
+    drawHandle: any;
+    cursorOnHover: string;
+    cursorOnDrag: string;
+    drawEdges: boolean;
+    anchor: "circumference" | "center" | "text" | ((node: any) => string);
+    edges: any;
+};
+type RewireOptions = typeof DEFAULT_OPTIONS8;
+export declare class Rewiring extends Module {
+    private _nodesToHighlight;
+    private _edgeHandles;
+    private _hoveredHandle;
+    private _hoveredNode;
+    private _hoverHandle;
+    private _grabHandle;
+    private _x;
+    private _y;
+    private _enabled;
+    private _options;
+    private _movedEdges;
+    private _edgeColors;
+    private _startNode;
+    private _interaction;
+    private _layer;
+    private _rewirableClass;
+    private _hiddenEdgesClass;
+    private _fixedEdges;
+    private _prevSettings;
+    private _onMouseUp;
+    private _onMouseDown;
+    private _onDragProgress;
+    private _onDragStart;
+    private _onDragEnd;
+    private _refreshHandles;
+    private _shouldInteractionStart;
+    private _refreshCanvas;
+    private _checkForHover;
+    onMounted(): void;
+    enable(options?: Partial<RewireOptions>): void;
+    setEdgesToRewire(edges?: any): void;
+    disable(): void;
+    enabled(): boolean;
+    private _restoreSettings;
+    private _disableCursorOnHover;
+    private _enableCursorOnHover;
+    private _displayMovedEdges;
+    private _displayAllEdges;
+    private _getAnchor;
+    private _getAnchorCenter;
+    private _shiftHandleOutward;
+    private _isInsideBoundary;
+    private _findBezierExitT;
+    private _clipBezier;
+    private _getTargetPosition;
+    private _getDragEndPos;
+    private _getNodeBezierHandlePos;
+    private _getEdgeHandlePosition;
+    private _getPointedNode;
+}
+export {};

package/types/internals/SchemaWatchPrimitives.d.ts

@@ -0,0 +1,75 @@
+export declare function triggerWatcher(watcher: any): void;
+export declare function checkPropertyEquality(a: any[], b: any[]): boolean;
+export declare function getModifiedSubProperty(changePath: any[], watchPath: any[]): any[] | null;
+export declare class DeepMap {
+    private _map;
+    private _arrays;
+    clear(): any;
+    delete(value: any): any;
+    get(value: any): any;
+    set(value: any, mapped: any): this;
+    keys(): any[];
+    values(): any[];
+    get size(): number;
+}
+export declare class PropertyInformation {
+    private _watcher;
+    setWatcher(watcher: any): void;
+    isNode(): boolean;
+    getPath(): any[];
+    getBoundaries(): {
+        min: number;
+        max: number;
+    } | null;
+    getValues(): any[];
+    getValueCount(value: any): number;
+    getCount(): number;
+    getType(): 'any' | 'number' | 'undefined';
+}
+export declare class NonObjectPropertyWatcher {
+    private _module;
+    private _isNode;
+    private _path;
+    private _filter;
+    private _unwindArrays;
+    private _onUpdateHandlers;
+    private _info;
+    private _triggerUpdate;
+    constructor(module: any, isNode: boolean, { path, filter, unwindArrays }: any);
+    onUpdate(handler: (info: any) => void): void;
+    getPropertyInfo(): any;
+    getPath(): any[];
+    destroy(): void;
+}
+export declare class ObjectPropertyWatcher {
+    private _module;
+    private _isNode;
+    private _path;
+    private _filter;
+    private _unwindArrays;
+    private _propertyList;
+    private _properties;
+    private _onAddHandlers;
+    private _onRemoveHandlers;
+    private _onUpdateHandlers;
+    constructor(module: any, isNode: boolean, { path, filter, unwindArrays }: any);
+    get path(): any[];
+    onPropertyAdded(handler: (property: string, info: any) => void): this;
+    onPropertyRemoved(handler: (property: string, info: any) => void): this;
+    onPropertyUpdated(handler: (property: string, info: any) => void): this;
+    getPath(): any[];
+    getProperties(): string[];
+    getPropertyInfo(property: string): any;
+    destroy(): void;
+    updateSubPropertiesToWatch(isNode: boolean, elements: any): void;
+    private _addSubPropertyToWatch;
+    private _triggerPropertyUpdate;
+    private _triggerHandlers;
+}
+export declare function addValues(watcher: any, values: any[], inArray?: boolean): void;
+export declare function removeValues(watcher: any, values: any[], inArray?: boolean): boolean;
+export declare function formatOptions2(value: any): {
+    path: string[];
+    filter: 'all' | 'visible';
+    unwindArrays: boolean;
+};

package/types/internals/Selection.d.ts

@@ -0,0 +1,52 @@
+import { Nodus } from '../Nodus';
+import { Module } from './Module';
+/**
+ * Internal selection state tracker.
+ * Maintains the set of currently selected node and edge indexes,
+ * and fires selection events through the Nodus event system.
+ */
+export declare class Selection extends Module {
+    private _selectedNodes;
+    private _selectedEdges;
+    constructor(nodus: Nodus<any, any>);
+    /**
+     * Select a node by its internal index.
+     */
+    selectNode(index: number): void;
+    /**
+     * Deselect a node by its internal index.
+     */
+    deselectNode(index: number): void;
+    /**
+     * Check if a node is currently selected.
+     */
+    isNodeSelected(index: number): boolean;
+    /**
+     * Get the set of all selected node indexes.
+     */
+    getSelectedNodeIndexes(): Set<number>;
+    /**
+     * Select an edge by its internal index.
+     */
+    selectEdge(index: number): void;
+    /**
+     * Deselect an edge by its internal index.
+     */
+    deselectEdge(index: number): void;
+    /**
+     * Check if an edge is currently selected.
+     */
+    isEdgeSelected(index: number): boolean;
+    /**
+     * Get the set of all selected edge indexes.
+     */
+    getSelectedEdgeIndexes(): Set<number>;
+    /**
+     * Clear all selections (both nodes and edges).
+     */
+    clear(): void;
+    /**
+     * Remove any references to elements that have been deleted.
+     */
+    onRemove(indexes: Set<number>, isNode: boolean): void;
+}

package/types/internals/SelectionModule.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Selection — manages selected state for nodes and edges.
+ *
+ * Backs selection with built-in style classes that are applied/removed as
+ * elements are selected, and fires selection events so other modules can react.
+ */
+import { Module } from './Module';
+export declare class SelectionModule extends Module {
+    shouldTriggerEvents: boolean;
+    private _selectedClass;
+    private _selectionExtremityHighlightedClass;
+    onMounted(): void;
+    setNodeAttributes(attrs: any, fullOverwrite?: boolean): void;
+    setEdgeAttributes(attrs: any, fullOverwrite?: boolean): void;
+    setEdgeExtremitiesAttributes(attrs: any, fullOverwrite?: boolean): void;
+    private _updateExtremityHighlightLayer;
+    setActive(elements: any, active: boolean | boolean[]): void;
+    areActive(elements: any): boolean;
+    getSelectedNodes(): any;
+    getSelectedEdges(): any;
+    getNonSelectedNodes(): any;
+    getNonSelectedEdges(): any;
+    disableEvents(): void;
+    enableEvents(): void;
+    clear(): void;
+}
+export { SelectionModule as Selection };

package/types/internals/Settings.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Settings — key-value store backed by per-key defaults and onChange callbacks.
+ *
+ * Each registered key carries a current value, a default, and an optional
+ * change handler. Updates are flattened so nested option objects can be
+ * addressed by dotted path; changed keys fire their handlers and emit a
+ * `settingsChange` event when an events module is present.
+ */
+import { Module } from './Module';
+export declare class Settings extends Module {
+    private _currentValue;
+    private _onChange;
+    private _defaultValues;
+    private _keys;
+    onReady(params: any): void;
+    register(key: string, defaultValue: any, onChange?: (newVal: any, oldVal?: any) => void, callNow?: boolean): this;
+    update(opts: any): any;
+    get(key?: string): any;
+    set(key: string, value: any): void;
+}

package/types/internals/Snapping.d.ts

@@ -0,0 +1,54 @@
+import { Module } from './Module';
+declare const DEFAULT_OPTIONS5: {
+    tolerance: number;
+    centerSnapDistance: number;
+    sideSnapDistanceFactor: number;
+    guidelineWidth: number;
+    guidelineColor: string;
+    preferredDistance: {
+        enabled: boolean;
+        ratio: number;
+        tolerance: number;
+    };
+    neighbours: {
+        enabled: boolean;
+        offset: number;
+        lineWidth: number;
+        lineColor: string;
+    };
+};
+type SnappingOptions = typeof DEFAULT_OPTIONS5;
+export declare class Snapping extends Module {
+    private _options;
+    private _enabled;
+    private _ysnap;
+    private _xsnap;
+    private _node;
+    private _nodes;
+    private _r;
+    private _vguideline;
+    private _hguideline;
+    private _gridResolution;
+    private _layer;
+    private _nodesByX;
+    private _nodesByY;
+    private _xGrid;
+    private _yGrid;
+    private _xList;
+    private _yList;
+    private _X;
+    private _Y;
+    private _R;
+    private _onNodeDragStart;
+    private _onNodeDragEnd;
+    onMounted(): void;
+    enable(options?: Partial<SnappingOptions>): void;
+    disable(): void;
+    enabled(): boolean;
+    private _onBeforeDrag;
+    private _cacheViewportData;
+    private _scan;
+    private _drawNeighbourGuidelines;
+    private _snap;
+}
+export {};

package/types/internals/Spatial.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Spatial — spatial index for hit-testing nodes and edges.
+ *
+ * Maintains a hierarchical grid over node and edge geometry so that pointer
+ * picks and rectangular selections can be resolved without scanning the whole
+ * graph.
+ */
+import { Module } from './Module';
+export declare class Spatial extends Module {
+    private _minCellSize;
+    private _index;
+    private _elementsToUpdate;
+    private _removedNodes;
+    private _removedEdges;
+    private _excludedNodes;
+    private _excludedEdges;
+    private _queryResult;
+    private _queryBounds;
+    constructor(nodus: any);
+    private _clear;
+    private _onGraphUpdate;
+    onMounted(): void;
+    reindex(): void;
+    getSize(): number;
+    _updateIndex(): void;
+    _updateItems(e: any, t: any): void;
+    getNodesInScreenByDistance(e: any): any;
+    getNearestNodesForNode(e: any, t?: number, s?: any): any;
+    getNearestNodes(e: number, t: number, s: number, o: any, c: any): any;
+    _getNearestNodes(e: number, t: number, s: number, o: any): any;
+    queryRaw(e: number, t: number, s: number, o: number): {
+        nodes: number[];
+        edges: number[];
+    };
+    queryRawProjected(e: number, t: number, s: number, o: number): {
+        nodes: number[];
+        edges: number[];
+    };
+    query(e: number, t: number, s: number, o: number): {
+        nodes: any;
+        edges: any;
+    };
+    queryProjected(e: number, t: number, s: number, o: number): {
+        nodes: any;
+        edges: any;
+    };
+    getNodesByBoundingBox(e: number, t: number, s: number, o: number, c?: boolean): any;
+    toggleDebug(_e: boolean): void;
+    renderDebug(_e?: any): void;
+}

package/types/internals/SpatialPrimitives.d.ts

@@ -0,0 +1,75 @@
+export declare function createControlPoint(): {
+    x: number;
+    y: number;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+type Bounds = [number, number, number, number];
+type Intersector = (id: number, x1: number, y1: number, x2: number, y2: number) => boolean;
+type TypedArrayConstructor = Int32ArrayConstructor | Uint32ArrayConstructor;
+export declare class FlatTable {
+    private _ArrayType;
+    private _capacity;
+    private readonly _MAX_LIST_SIZE;
+    private readonly _BIG_LIST;
+    private _freeIndex;
+    private _buffer;
+    private _sizes;
+    private _bigLists;
+    private _nextIndex;
+    private _idToIndex;
+    private _constList;
+    constructor(arrayType?: TypedArrayConstructor, capacity?: number, maxListSize?: number);
+    clear(): void;
+    has(key: number): boolean;
+    addEntry(key: number): number;
+    removeEntry(key: number): void;
+    addTo(key: number, value: number): void;
+    removeFrom(key: number, value: number): void;
+    getItems(key: number): number[] | undefined;
+    get occupiedCount(): number;
+    getIdToIndexMap(): Map<number, number>;
+    getSizes(): Uint8Array;
+    getBuffer(): Int32Array | Uint32Array;
+    getBigLists(): number[][];
+    getMaxListSize(): number;
+    getBigListMarker(): number;
+    keys(): number[];
+    private _expand;
+}
+export declare class HGrid {
+    private readonly _intersects;
+    private readonly _getBounds;
+    private readonly _cells;
+    private readonly _offset;
+    private readonly _maxLevels;
+    private readonly _mortonMax;
+    private readonly _bitsForZoom;
+    private _objectsAtLevel;
+    private readonly _min;
+    private readonly _max;
+    private readonly _resolution;
+    private _minCellSize;
+    private _bounds;
+    private _occupied;
+    private readonly _idToCode;
+    private readonly _codeCache;
+    constructor(intersector: Intersector, boundsGetter: (id: number) => Bounds, minCellSize?: number, halfWorldSize?: number);
+    private _code;
+    private _decode;
+    get size(): number;
+    has(id: number): boolean;
+    clear(): void;
+    insert(id: number, x1?: number, y1?: number, x2?: number, y2?: number): number;
+    remove(id: number): this;
+    query(x1: number, y1: number, x2: number, y2: number): number[];
+    private _queryByIteratingCells;
+    private _keyToBBox;
+    getIds(): number[];
+    getBounds(id: number): Bounds;
+}
+export declare function createBoundsGetter(graph: any): (id: number) => Bounds;
+export declare function renderDebug(ctx: CanvasRenderingContext2D, index: any, bounds: [number, number, number, number], extra?: any): void;
+export {};

package/types/internals/Storage.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Storage: maps element IDs → internal indexes and manages FlexArrays.
+ *
+ * Allocates a dense, reusable integer index for each element ID and keeps the
+ * registered FlexArrays and IndexLists sized in step with the live index range.
+ */
+import { FlexArray } from './FlexArray';
+import { IndexList } from './IndexList';
+interface FlexArrayOptions {
+    storage: any;
+    name?: string;
+    size?: number;
+    default?: any;
+}
+export declare class Storage {
+    /** Bumped on every structural mutation (add/remove/clear). A cheap, reliable change signal —
+     * consumers (e.g. the Rust GraphCore cache) rebuild only when this changes. */
+    _version: number;
+    private _nextIndex;
+    private _freeIndexes;
+    private _indexesToBeFreed;
+    _idToIndex: Record<string | number, number>;
+    _indexToId: (string | number | undefined)[];
+    private _flexArrays;
+    private _defaultValues;
+    _flexArraysByName: Record<string, FlexArray>;
+    private _indexLists;
+    private _name;
+    _idFlexArray: FlexArray;
+    constructor(isNode: boolean);
+    addElements(ids: (string | number)[]): Uint32Array;
+    removeElements(indexes: Uint32Array | number[]): void;
+    clear(): void;
+    has(index: number): boolean;
+    getIndex(id: string | number, required?: boolean): number | undefined;
+    createFlexArray(opts: FlexArrayOptions, registerByName: boolean): FlexArray;
+    getFlexArray(name: string): FlexArray | undefined;
+    getAllFlexArrays(): Record<string, FlexArray>;
+    createIndexList(): IndexList;
+    getId(index: number): string | number | undefined;
+    getMaxIndex(): number;
+    private _removeIndex;
+    private _getNextIndex;
+    freeIndexes(): void;
+}
+export {};

package/types/internals/StyleRulesModule.d.ts

@@ -0,0 +1,21 @@
+/**
+ * StyleRulesModule — manages style rules (attribute layers with priority ordering).
+ * Faithfully translated from /tmp/nodus_extracted/StyleRulesModule.js
+ */
+import { Module } from './Module';
+export declare class StyleRulesModule extends Module {
+    private _idCounter;
+    private _rules;
+    onMounted(): void;
+    private _get;
+    private _updatePriorities;
+    addRule(opts?: any): any;
+    getRuleIndex(id: number): number | null;
+    setRuleIndex(id: number, idx: number): Promise<any>;
+    updateRule(id: number, opts: any): Promise<any>;
+    getRuleDefinition(id: number): any;
+    destroyRule(id: number): Promise<any>;
+    refreshRule(id: number): Promise<any>;
+    refreshAllRules(): Promise<any>;
+    getRuleList(): any[];
+}

package/types/internals/Synchronizer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Synchronizer — debounce-until-idle utility used across modules.
+ *
+ * Defers callbacks until the application is idle (no pointer button held and
+ * no animation frame in flight), resetting the wait whenever interaction or
+ * rendering activity occurs.
+ */
+import { Module } from './Module';
+export declare class Synchronizer extends Module {
+    private _delayedCalls;
+    private _isIdle;
+    onMounted(): void;
+    private _nextTimeIdle;
+    debounceIdle<T>(fn: () => T, delay?: number): (() => Promise<T>) & {
+        cancel: () => void;
+    };
+}