@kortexya/nodus 0.1.0

package/types/internals/AlgorithmsPrimitives.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Algorithm support primitives. The TS algorithm BODIES that used to live here
+ * (detectCyclesDirected/CyclesFinder/kruskal_default/betweennes/fisheye) were
+ * deleted after their Rust ports went live unconditionally — frozen copies
+ * remain in scripts/oracles/algorithms-primitives-oracle.ts for the gates.
+ * PrioritySet stays: it backs the TS A* in Algorithms.ts, which is the ONLY
+ * implementation for the custom-cost/heuristic/subgraph parameter cases.
+ */
+export declare function noop(): void;
+export declare class PrioritySet {
+    private readonly _priorities;
+    private readonly _items;
+    constructor(priorities: Float32Array);
+    add(value: number): void;
+    has(value: number): boolean;
+    isEmpty(): boolean;
+    removeMin(): number;
+}

package/types/internals/Animations.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Animations — timing-based animation player driven by the render loop.
+ *
+ * Each registered animation advances on every `beforeNewFrame` event,
+ * mapping elapsed time to a normalized progress value through an easing
+ * function before invoking its per-frame callback. Completed animations
+ * resolve their promise and are removed from the active list.
+ */
+import { Module } from './Module';
+export declare const easingFunctions: Record<string, (t: number) => number>;
+declare const DEFAULTS: {
+    duration: number;
+    easing: string | ((t: number) => number);
+    callback: () => void;
+    resolve: (_v: any) => void;
+    startAfter: number;
+};
+export interface AnimEntry {
+    func: (t: number) => void;
+    easing: (t: number) => number;
+    duration: number;
+    callback: (cancelled?: boolean) => void;
+    resolve: (v: any) => void;
+    startAfter: number;
+    creationDate: number;
+    done: boolean;
+    id: number;
+}
+export type AnimOptions = Partial<typeof DEFAULTS> & {
+    func?: (t: number) => void;
+};
+export declare class Animations extends Module {
+    private _animationList;
+    private _update;
+    onMounted(): void;
+    play(fn: (t: number) => void, opts: AnimOptions): AnimEntry | null;
+    cancel(entry: AnimEntry, jumpToEnd?: boolean): void;
+}
+export {};

package/types/internals/AttributePathPrimitives.d.ts

@@ -0,0 +1,2 @@
+export declare function getFlattenedKeys(obj: any, prefix?: string, out?: string[]): string[];
+export declare function getPathsWithAlias(attrs: any, _isNode: boolean): string[];

package/types/internals/Brand.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Brand — renders an HTML brand/logo overlay pinned to a container corner.
+ *
+ * Implemented as a Module: it creates an absolutely-positioned element on the
+ * dedicated `brand` layer and offsets it from the chosen corner using the
+ * configured horizontal/vertical margins.
+ */
+import { Module } from './Module';
+type Position = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+interface BrandOptions {
+    position?: Position;
+    horizontalMargin?: number;
+    verticalMargin?: number;
+    className?: string;
+}
+export declare class Brand extends Module {
+    private _brand;
+    onMounted(): void;
+    set(html: string, opts?: BrandOptions): HTMLElement;
+    remove(): void;
+}
+export {};

package/types/internals/Camera.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Camera — manages the viewport transform (pan, zoom, and rotation) and
+ * provides animated transitions between view states. Extends Module so it can
+ * react to container and resize events and coordinate with the animation,
+ * settings, and DOM subsystems.
+ */
+import { Module } from './Module';
+export declare class Camera extends Module {
+    private _x;
+    private _y;
+    private _zoom;
+    private _angle;
+    private _sinAngle;
+    private _cosAngle;
+    private _dimensions;
+    private _minZoom;
+    private _maxZoom;
+    private _timeout;
+    private _cornerCosSin;
+    private _moveAnimation;
+    private _zoomAnimation;
+    private _rotateAnimation;
+    onMounted(): void;
+    get x(): number;
+    get y(): number;
+    get zoom(): number;
+    get angle(): number;
+    get width(): number;
+    get height(): number;
+    moveEnd(type: string): void;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    getCenter(): {
+        x: number;
+        y: number;
+    };
+    setCenter(center: {
+        x: number;
+        y: number;
+    }, opts?: any): Promise<void>;
+    move(delta: {
+        x: number;
+        y: number;
+    }, opts?: any): Promise<void>;
+    getZoom(): number;
+    setZoom(targetZoom: number, opts?: any, center?: {
+        x?: number;
+        y?: number;
+    }): Promise<void>;
+    private _applyZoomLimits;
+    zoomIn(opts?: any, center?: {
+        x?: number;
+        y?: number;
+    }): Promise<void>;
+    zoomOut(opts?: any, center?: {
+        x?: number;
+        y?: number;
+    }): Promise<void>;
+    getAngle(): number;
+    setAngle(target: number, opts?: any): Promise<void>;
+    rotate(delta: number, opts?: any): Promise<void>;
+    getScreenCenter(): {
+        x: number;
+        y: number;
+    };
+    graphToScreenCoordinates(pt: {
+        x: number;
+        y: number;
+    }, out?: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    screenToGraphCoordinates(pt: {
+        x: number;
+        y: number;
+    }, out?: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    projectBounds(bounds: number[], out?: number[]): number[];
+    screenToGraphVector(v: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    getView(): {
+        x: number;
+        y: number;
+        zoom: number;
+        angle: number;
+        width: number;
+        height: number;
+    };
+    setView(opts: any, animOpts?: any): Promise<void>;
+    moveTo(target: any, opts?: any): Promise<void>;
+    moveToBounds(bounds: any, opts?: any): Promise<void>;
+    private _reloadDimensions;
+    animationInProgress(): boolean;
+    getProjectedScreenBounds(padding?: number): number[];
+    calculateBoxCornerAngles(): void;
+    getCornerCos(i: number): number;
+    getCornerSin(i: number): number;
+    private _reset;
+    clone(overrides?: any): Camera;
+}

package/types/internals/CameraInteractions.d.ts

@@ -0,0 +1,15 @@
+import { Module } from './Module';
+export declare class CameraInteractions extends Module {
+    private _zooming;
+    debug: boolean;
+    private _rotationStart;
+    private _smoothZoom;
+    constructor(e: any, t?: boolean);
+    onMounted(): void;
+    _setupInteractions(): void;
+    _rotate({ x: e, y: t }: {
+        x: number;
+        y: number;
+    }): void;
+    _updateVisibility(e: string, t: boolean): void;
+}

package/types/internals/CameraInteractionsPrimitives.d.ts

@@ -0,0 +1,18 @@
+export declare const MOUSE_WHEEL_THROTTLE = 40;
+export declare const DEFAULT_ZOOM_SPEED = 0.15;
+export declare const DEFAULT_ZOOM_MODIFIER: number;
+export declare const DEFAULT_MIN_ZOOM: ({ graphWidth, graphHeight, viewWidth, viewHeight, }: {
+    graphWidth: number;
+    graphHeight: number;
+    viewWidth: number;
+    viewHeight: number;
+}) => number;
+export declare const DEFAULT_MAX_ZOOM: ({ smallestNodeSize, viewWidth, viewHeight, }: {
+    smallestNodeSize: number;
+    viewWidth: number;
+    viewHeight: number;
+}) => number;
+export declare const DEFAULT_EASING = "cubicOut";
+export declare function throttle(fn: (...args: any[]) => any, delay: number): (...args: any[]) => any;
+export declare function getSmoothScale(delta: number, speed: number): number;
+export declare function isModifierKey(domEvent: any, key: any, keyboard: any): boolean;

package/types/internals/Captor.d.ts

@@ -0,0 +1,56 @@
+import { Module } from './Module';
+export declare class Captor extends Module {
+    spatialIndexMarginRatio: number;
+    private _elt;
+    private _hoveredElt;
+    private _draggedElt;
+    private _hover;
+    private _isFiringDragEnd;
+    private _disabledCounter;
+    private _accDx;
+    private _accDy;
+    private _prevX;
+    private _prevY;
+    private _buttons;
+    private _onGraphChanged;
+    onMounted(): void;
+    triggerUnhover(): void;
+    triggerDetection(): void;
+    getPointedElement(): any;
+    getDraggedElement(): any;
+    isAnyButtonPressed(): boolean;
+    isAnyButtonDragging(): boolean;
+    isButtonPressed(e: string): boolean;
+    isLeftPressed(): boolean;
+    getCursorPosition(): {
+        x: number;
+        y: number;
+    };
+    getCursorInformation(): {
+        x: number;
+        y: number;
+        target: any;
+    };
+    setDetectionEnabled(value: boolean): void;
+    _resetCurrent(e: number, t: number): void;
+    _onMove({ domEvent: e, x: t, y: s, source: o }: any): void;
+    _onDocumentMove({ domEvent: e, x: t, y: s, source: o }: any): void;
+    _onDocumentUp({ domEvent: e, x: t, y: s, source: o, button: c }: any): void;
+    _onDown({ domEvent: e, x: t, y: s, button: o, source: c }: any): void;
+    _onDoubleClick({ domEvent: e, x: t, y: s, button: o, source: c }: any): void;
+    _onUp({ domEvent: e, x: t, y: s, button: o, source: c }: any): void;
+    _onClick({ domEvent: e, x: t, y: s, button: o, source: c }: any): void;
+    _onWheel({ domEvent: e, x: t, y: s, delta: o, source: c, dx: p, dy: At }: any): void;
+    _fireDragEnd(e: any, t: number, s: number, o: string, c: any): void;
+    _storeDXY(e: number, t: number): void;
+    _getStoredDXY(): {
+        dx: number;
+        dy: number;
+    };
+    _setPointerPosition(e: number, t: number): {
+        dx: number;
+        dy: number;
+    };
+    _detectElement(e: number, t: number, s: boolean, o: boolean): void;
+    detectElementAt(e: number, t: number, s: boolean, o: boolean): any;
+}

package/types/internals/CaptorPrimitives.d.ts

@@ -0,0 +1,9 @@
+export declare const MOVE_EVENTS: string[];
+export declare const DOWN_EVENTS: string[];
+export declare const UP_EVENTS: string[];
+export declare const CLICK_EVENTS: string[];
+export declare const DOUBLE_CLICK_EVENTS: string[];
+export declare const WHEEL_EVENTS: string[];
+export declare const MAX_HOVER_EDGES = 500;
+export declare function getSource(eventName: string): 'mouse' | 'touch' | 'virtual';
+export declare function isDuplicateMouseEvent(domEvent: any, _type: string): boolean;

package/types/internals/ClassModule.d.ts

@@ -0,0 +1,42 @@
+/**
+ * ClassModule — named attribute layers ("classes") for nodes and edges.
+ * Faithfully translated from /tmp/nodus_extracted/ClassModule.js
+ */
+import { Module } from './Module';
+export declare class ClassModule extends Module {
+    private _builtinClasses;
+    private _userClasses;
+    private _classesByName;
+    private _onExcludedStateChange;
+    private _onClearGraph;
+    private _onRemoveElements;
+    onMounted(): void;
+    private _getClassList;
+    createClass({ name, isBuiltin, after, nodeAttributes, nodeDependencies, nodeOutput, edgeAttributes, edgeDependencies, edgeOutput, }?: any): any;
+    removeClass(name: string): Promise<void>;
+    private _updatePriorities;
+    private _get;
+    getIndex(name: string): number;
+    setIndex(name: string, idx: number): void;
+    update(name: string, { nodeAttributes, edgeAttributes, nodeDependencies, edgeDependencies, nodeOutput, edgeOutput, fullOverwrite }?: any): void;
+    getDefinition(name: string): any;
+    private _addOrRemoveClassesToElements;
+    private _animatedAttributesUpdatePositions;
+    private _getAnimatedAttributes;
+    addClassesToElements(names: string[], elements: any, opts?: any): Promise<any>;
+    removeClassesFromElements(names: string[], elements: any, opts?: any): Promise<any>;
+    hasSingleElementClass(name: string, element: any): boolean;
+    getElementsClassList(elements: any, opts?: any): string[][];
+    private _addClassNamesToList;
+    getClassByName(name: string, throwIfMissing?: boolean): any;
+    getClassList(): any[];
+    getElementsByClass(name: string, filter?: string): {
+        nodes: any[];
+        edges: any[];
+    };
+    private _onClassEvent;
+    onNodeClassAdded(name: string, callback: any): void;
+    onNodeClassRemoved(name: string, callback: any): void;
+    onEdgeClassAdded(name: string, callback: any): void;
+    onEdgeClassRemoved(name: string, callback: any): void;
+}

package/types/internals/ConnectNodes.d.ts

@@ -0,0 +1,23 @@
+import { Module } from './Module';
+export declare class ConnectNodes extends Module {
+    private _enabled;
+    private _blockId;
+    private _cursorEnabled;
+    private _engine;
+    private _group;
+    private _depth;
+    private _interaction;
+    private _options;
+    private _prevSettings;
+    private _startNode;
+    private _startPos;
+    private _endPos;
+    onMounted(): void;
+    _onStart(e: any): void;
+    _onMove(e: number, t: number): void;
+    _onStop(): void;
+    _drawLine(): void;
+    enable(e?: Record<string, any>): this;
+    disable(): this;
+    enabled(): boolean;
+}

package/types/internals/CurvatureManager.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CurvatureManager — computes curvature for parallel edges and self-loops.
+ *
+ * Registered as a graphics attribute layer so each edge's `curvature`
+ * attribute is recomputed in response to the relevant settings changes.
+ */
+import { Module } from './Module';
+export declare class CurvatureManager extends Module {
+    private _attributeLayer;
+    private _context;
+    onMounted(): void;
+    computeCurvature(edge: any, filter?: string, filterFn?: (e: any) => boolean): number;
+    private _addAttributeLayer;
+}

package/types/internals/DataModule.d.ts

@@ -0,0 +1,29 @@
+/**
+ * DataModule — raw node/edge data storage with dot-path access and batched events.
+ *
+ * Holds the arbitrary `data` payload attached to each node and edge, supports
+ * reading and writing nested properties via dot-paths, and coalesces mutations
+ * into batched update events that are flushed on the next frame.
+ */
+import { Module } from './Module';
+export declare class DataModule extends Module {
+    private _nodeChanges;
+    private _edgeChanges;
+    private _shouldTriggerEvents;
+    private _nodeDataList;
+    private _edgeDataList;
+    private _nodeList;
+    private _edgeList;
+    onMounted(): void;
+    private _onAddElements;
+    setProperty(elements: any, path: any, value: any, { dispatch, virtual }?: {
+        dispatch?: boolean | undefined;
+        virtual?: boolean | undefined;
+    }): void;
+    getProperty(elements: any, path: any): any[];
+    private _setDataProperty;
+    private _getDataProperty;
+    private _scheduleEvents;
+    private _triggerEvents;
+    private _prepareEvtPayload;
+}

package/types/internals/Disabled.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Disabled — manages the disabled state for nodes and edges.
+ *
+ * Implemented as a Module that maintains a built-in `_disabled` class. Disabling
+ * an element applies that class (and clears any selection), which in turn drives
+ * the muted default styling and fires the corresponding nodes/edges
+ * disabled/enabled events.
+ */
+import { Module } from './Module';
+export declare class Disabled extends Module {
+    shouldTriggerEvents: boolean;
+    private _disabledClass;
+    setDisabledNodeAttributes(attrs: any, fullOverwrite?: boolean): void;
+    setDisabledEdgeAttributes(attrs: any, fullOverwrite?: boolean): void;
+    updateNodeAttributes(attrs: any, fullOverwrite?: boolean): void;
+    updateEdgeAttributes(attrs: any, fullOverwrite?: boolean): void;
+    onMounted(): void;
+    setActive(elements: any, active: boolean | boolean[]): void;
+    areActive(elements: any): boolean;
+    getDisabledNodes(): any;
+    getDisabledEdges(): any;
+    getEnabledNodes(): any;
+    getEnabledEdges(): any;
+    disableEvents(): void;
+    enableEvents(): void;
+    clear(): void;
+}

package/types/internals/DomModule.d.ts

@@ -0,0 +1,87 @@
+/**
+ * DomModule owns the rendering frame loop and the DOM surface that Nodus draws into.
+ *
+ * Responsibilities:
+ * - Drives the requestAnimationFrame loop, sequencing before/on/after-frame work and
+ *   firing the corresponding frame events each tick.
+ * - Manages the host container and its stacked layer elements, including insertion order
+ *   and automatic resizing.
+ * - Tracks size changes via a ResizeObserver and emits resize events.
+ * - Handles focus state, fullscreen transitions, scoped event-listener registration,
+ *   and teardown of timeouts and listeners on destroy.
+ */
+import { Module } from './Module';
+export declare class DomModule extends Module {
+    private _width;
+    private _height;
+    private _resizeObserver;
+    private _layers;
+    private _focus;
+    private _container;
+    private _isFullScreen;
+    private _beforeNextFramePromises;
+    private _afterNextFramePromises;
+    private _onNextFramePromises;
+    private _refreshUntil;
+    private _currentTime;
+    private _timeouts;
+    private _isDestroyed;
+    private _onDetachDom;
+    private _isRealBrowser;
+    private _isDocumentReady;
+    private _inFrame;
+    private _mustRefresh;
+    private _nextFrame;
+    private _onWindowFocus;
+    private _onFullscreenChange;
+    private _resize;
+    constructor(nodus: any);
+    onMounted(): void;
+    onReady(params: any): void;
+    addWindowEventListener(event: string, handler: EventListenerOrEventListenerObject, opts?: any): this;
+    addDirectWindowEventListener(event: string, handler: EventListener, opts?: any): void;
+    removeDirectWindowEventListener(event: string, handler: EventListener): void;
+    addDocumentEventListener(event: string, handler: EventListener, opts?: any): EventListener;
+    removeDocumentEventListener(event: string, handler: EventListener): void;
+    addMediaListener(query: string, handler: (e: MediaQueryListEvent) => void): void;
+    addElementEventListener(el: EventTarget, event: string, handler: EventListenerOrEventListenerObject, opts?: any): EventListenerOrEventListenerObject;
+    detachFromDom(): void;
+    setTimeout(fn: () => void, delay?: number): ReturnType<typeof setTimeout>;
+    clearTimeout(id: ReturnType<typeof setTimeout> | null): null;
+    clearAllTimeouts(): void;
+    stopFrames(): void;
+    isDestroyed(): boolean;
+    getDimensions(): {
+        width: number;
+        height: number;
+    };
+    setDimensions(size: {
+        width: number;
+        height: number;
+    }): void;
+    setLayer(name: string, element: HTMLElement | null, { automaticResize }?: {
+        automaticResize?: boolean | undefined;
+    }): void;
+    setContainer(container: HTMLElement | string): void;
+    getContainer(): HTMLElement | null;
+    appendElement(el: HTMLElement): void;
+    focus(): void;
+    blur(): void;
+    hasFocus(): boolean;
+    forceResize(): void;
+    private _beforeOrAfterNextFrame;
+    beforeNextFrame(): Promise<void>;
+    onNextFrame(): Promise<void>;
+    afterNextFrame(): Promise<void>;
+    refresh(until?: number): void;
+    private _emptyContainer;
+    private _fillContainer;
+    private _updateContainerContent;
+    private _refresh;
+    private _playFrame;
+    isPlayingFrame(): boolean;
+    setFullScreen(value: boolean): Promise<void>;
+    isFullScreen(): boolean;
+    debounceBeforeFrame(fn: () => void): () => Promise<void>;
+    destroy(): void;
+}

package/types/internals/DragModule.d.ts

@@ -0,0 +1,14 @@
+import { Module } from './Module';
+export declare class DragModule extends Module {
+    private _dragged;
+    private _start;
+    private _end;
+    private _onBeforeDrag;
+    private _startDrag;
+    private _shouldDrag;
+    private _onDragStart;
+    private _onDrag;
+    private _onDragEnd;
+    onMounted(): void;
+    isDragging(): boolean;
+}

package/types/internals/ElementSet.d.ts

@@ -0,0 +1,17 @@
+export declare class ElementSet {
+    private _graph;
+    private _nodes;
+    private _edges;
+    constructor(graph: any, name?: string);
+    private _get;
+    addOrRemoveElements(elements: any, add: boolean): any;
+    addElements(elements: any): any;
+    removeElements(elements: any): any;
+    hasElement(element: any): boolean;
+    clear(): void;
+    isEmpty(): boolean;
+    getElements(): {
+        nodes: any;
+        edges: any;
+    };
+}

package/types/internals/EventsModule.d.ts

@@ -0,0 +1,41 @@
+/**
+ * EventsModule: the internal event bus for Nodus.
+ *
+ * Provides named event channels that callers can subscribe to (`on`/`once`),
+ * unsubscribe from (`off`), and dispatch (`fire`). Each channel is backed by an
+ * EventTarget2 instance that manages its own ordered list of handlers. The
+ * module also exposes a throttled/debounced "idle" signal that fires after
+ * graph activity (view changes, layout, node/edge mutations) settles.
+ */
+import { Module } from './Module';
+declare class EventTarget2 {
+    private _subscribers;
+    private _handlers;
+    private _onceWrappers;
+    private _reverseOrder;
+    private _name;
+    constructor(reverseOrder: boolean, name: string);
+    trigger(data: any): this;
+    on(handler: Function): this;
+    once(handler: Function): this;
+    off(handler: Function): this;
+    destroy(): void;
+}
+export declare class EventsModule extends Module {
+    private _onAnyEvents;
+    _registeredEvents: Record<string, EventTarget2>;
+    onIdle: () => void;
+    fireIdle: () => void;
+    constructor(nodus: any);
+    onMounted(): void;
+    isRegistered(name: string): boolean;
+    register(names: string[], _deps?: string[]): void;
+    onAnyEvent(handler: Function): void;
+    on(event: string | string[], handler: Function): this;
+    off(handler: Function): this;
+    fire(event: string, data?: any): this;
+    once(event: string | string[], handler: Function): this;
+    private _getEvent;
+    destroy(): void;
+}
+export {};

package/types/internals/FlexArray.d.ts

@@ -0,0 +1,54 @@
+/**
+ * FlexArray: typed array storage primitive used throughout Nodus internals.
+ * Supports storage types: 1, 8, 16, 32 (bit sizes), 'int32',
+ * 'float32'/'float64' (typed float buffers — unset reads as NaN),
+ * 'any' (JS array), 'resource' (string interning).
+ */
+import { type DTypeTag, type WasmBacked } from './wasmColumns';
+type StorageType = 1 | 8 | 16 | 32 | 'any' | 'resource' | 'int32' | 'float32' | 'float64';
+interface FlexArrayOptions {
+    storage: StorageType;
+    name?: string;
+    size?: number;
+    default?: any;
+}
+export declare class FlexArray implements WasmBacked {
+    _id: number;
+    _name: string | undefined;
+    _storage: StorageType;
+    _elementSize: any;
+    _nbElements: number;
+    _defaultValue: any;
+    _BASE_VALUE: any;
+    _buffer: any;
+    _initialized: boolean;
+    /** WASM FlexColumn backing this array's buffer, or null for a JS-owned buffer. */
+    _wasmColumn: any;
+    _wasmTag: DTypeTag | null;
+    _fallback: FlexArray | null;
+    _byName: Record<string, number> | undefined;
+    _byIndex: any[] | undefined;
+    _nextIndex: number | undefined;
+    _rawGet: (index: number) => any;
+    set: (index: number, value: any) => void;
+    getMultiple: (indexes: Uint32Array | number[]) => any[];
+    get(i: number): any;
+    _getWithFallback(i: number): any;
+    constructor(opts: FlexArrayOptions);
+    getName(): string;
+    getValues(): string[];
+    setDefaultValue(val: any): void;
+    _initialize(): void;
+    setFallback(fallback: FlexArray): void;
+    grow(newSize: number): void;
+    /** Re-derive the view over the (possibly moved/grown) WASM column. B2 invariant. */
+    _rederiveView(): void;
+    capacity(): number;
+    byteSize(): number;
+    isInitialized(): boolean;
+    fill(indexes: Uint32Array | number[], value: any): void;
+    setMultiple(indexes: Uint32Array | number[], values: any, dispatch?: boolean): void;
+    reset(): this;
+    buffer(): any;
+}
+export {};