/** @ignore */ /** */
import type { IPoint } from "../../util/IPoint";
import type { IRendererEvent, IRendererEvents, IPointerEvent, Id } from "../backend/Renderer";
import { ArrayDisposer, IDisposer, CounterDisposer } from "../../util/Disposer";
/**
 * A display object as the interaction code sees it.
 *
 * @ignore
 */
export interface IInteractiveNode<N> {
    interactive: boolean;
    wheelable: boolean;
    cursorOverStyle?: string;
    _replacedCursorStyle?: string;
    _parent: N | undefined;
    contains(child: N): boolean;
    shouldCancelTouch(): boolean;
}
/**
 * @ignore
 */
export interface IInteractionEvent<A> extends IRendererEvent<A> {
    originalPoint: IPoint;
    bbox: DOMRect;
}
/**
 * What the renderer provides: its DOM element, DOM event to chart
 * coordinates, and a hit test.
 *
 * @ignore
 */
export interface IInteractionHost<N> {
    readonly view: HTMLElement;
    getEvent<A extends IPointerEvent>(originalEvent: A): IInteractionEvent<A>;
    /**
     * The object under `point`: `false` over empty chart area, `undefined`
     * outside the chart or when `target` is not the renderer's own element.
     */
    _getHitTarget(point: IPoint, bbox: DOMRect, target: Node | null): N | undefined | false;
}
/**
 * @ignore
 */
interface IEvent<N, Key extends keyof IRendererEvents> {
    object: N;
    context: unknown;
    callback: (event: IRendererEvents[Key]) => void;
    disposed: boolean;
}
/**
 * @ignore
 */
interface IEvents<N, Key extends keyof IRendererEvents> {
    disposer: IDisposer;
    callbacks: Array<IEvent<N, Key>>;
    dispatching: boolean;
    cleanup: boolean;
}
/**
 * Pointer input for one renderer: DOM listeners, hover, drag, click,
 * double-click, wheel, cursor and tap-to-activate. Renderer-neutral; the
 * host supplies coordinates and the hit test.
 *
 * @ignore
 */
export declare class InteractionManager<N extends IInteractiveNode<N>> extends ArrayDisposer {
    protected _host: IInteractionHost<N>;
    interactionsEnabled: boolean;
    tapToActivate: boolean;
    tapToActivateTimeout: number;
    _touchActive: boolean;
    protected _touchActiveTimeout?: number;
    _hovering: Set<N>;
    _dragging: Array<{
        id: Id;
        value: N;
    }>;
    _mousedown: Array<{
        id: Id;
        value: N;
    }>;
    protected _listeners: {
        [key: string]: CounterDisposer;
    };
    protected _events: {
        [Key in keyof IRendererEvents]?: IEvents<N, Key>;
    };
    protected _lastPointerMoveEvent: {
        events: Array<IPointerEvent>;
        target: Node | null;
        native: boolean;
    } | undefined;
    constructor(_host: IInteractionHost<N>);
    protected _delayTouchDeactivate(): void;
    /**
     * Re-runs hover for the last pointer position, after a render may have
     * moved things under it.
     */
    afterRender(): void;
    _withEvents<Key extends keyof IRendererEvents>(key: Key, f: (events: IEvents<N, Key>) => void): void;
    _dispatchEventAll<Key extends keyof IRendererEvents>(key: Key, event: IRendererEvents[Key]): void;
    _dispatchEvent<Key extends keyof IRendererEvents>(key: Key, target: N, event: IRendererEvents[Key]): boolean;
    _dispatchMousedown(originalEvent: IPointerEvent, originalTarget: Node | null): void;
    _dispatchGlobalMousemove(originalEvent: IPointerEvent, originalTarget: Node | null, native: boolean): void;
    removeHovering(obj: N): void;
    _dispatchGlobalMouseup(originalEvent: IPointerEvent, native: boolean): void;
    _dispatchDragMove(originalEvent: IPointerEvent): void;
    _dispatchDragEnd(originalEvent: IPointerEvent, originalTarget: Node | null): void;
    _dispatchDoubleClick(originalEvent: IPointerEvent, originalTarget: Node | null): void;
    _dispatchWheel(originalEvent: WheelEvent, originalTarget: Node | null): void;
    _makeSharedEvent(key: string, f: () => IDisposer): IDisposer;
    _onPointerEvent(name: string, f: (event: Array<IPointerEvent>, target: Node | null, native: boolean) => void): IDisposer;
    _initEvent(key: keyof IRendererEvents): IDisposer | undefined;
    addEvent<C, Key extends keyof IRendererEvents>(object: N, key: Key, callback: (this: C, event: IRendererEvents[Key]) => void, context?: C): IDisposer;
}
export {};
//# sourceMappingURL=Interaction.d.ts.map