import { InteractingEntry, EventType } from '../../../types/vega-chart';
import { BaseDrawer } from '../drawers/base-drawer';
export declare type BaseDrawPiece = HTMLCanvasElement | SVGGElement | SVGPathElement;
export declare type DrawPiece = BaseDrawPiece | BaseDrawPiece[];
export declare type InteractorEventRegistryType = Map<EventType, InteractingEntry[]>;
export declare type InteractorDrawerRegistryType = WeakMap<BaseDrawer<unknown>, WeakMap<DrawPiece, InteractingEntry[]>>;
/**
 * This is a TypeScript code that defines an abstract class `BaseInteractor` with a generic type `T` that extends either `SVGElement` or `HTMLCanvasElement`.
 */
export declare abstract class BaseInteractor<T extends SVGElement | HTMLCanvasElement> {
  protected context: T;
  protected interactingEntryForEventRegistry: InteractorEventRegistryType;
  protected interactingEntryForDrawerRegistry: InteractorDrawerRegistryType;
  /**
   * This is a constructor function that takes a parameter of type T and sets it as a protected property called "context".
   *
   * @param {SVGElement | HTMLCanvasElement} context - The "context" parameter is a protected property of a class constructor that is
   * of type "T". It is used to store a reference to an object or data that is required by the class
   * methods to perform their tasks. The "protected" keyword means that the property can only be
   * accessed within the class
   */
  constructor(context: T);
  /**
   * This function registers an interacting entry with a drawer, draw piece, and event type in an interactor registry.
   *
   * @param {BaseDrawer<unknown>} drawer - The drawer parameter is an instance of a class that extends the BaseDrawer class,
   * which is used for drawing on a canvas or other graphical surface.
   * @param {DrawPiece} drawPiece - DrawPiece is a type that represents a specific piece that can be
   * drawn on a canvas or other graphical surface. It could include information such as the shape,
   * color, size, and position of the piece.
   * @param {InteractingEntry} interactingEntry - InteractingEntry is a data structure that represents
   * an interaction between a user and a graphical element on the screen. It contains information such
   * as the type of event that triggered the interaction (e.g. mouse click, touch)
   */
  register(drawer: BaseDrawer<unknown>, drawPiece: DrawPiece, interactingEntry: InteractingEntry): void;
  /**
   * This function unregisters a drawer from the interactor registry.
   *
   * @param {BaseDrawer<unknown>} drawer - The parameter `drawer` is of type `BaseDrawer<unknown>`. It is an object that
   * represents a drawer and is used to unregister the drawer from the `interactorRegistry`. The
   * `interactorRegistry` is a `WeakMap` that stores a mapping between an `Interactor` and
   */
  unregisterByDrawer(drawer: BaseDrawer<unknown>): void;
  /**
   * This function handles mouse events for registered interactor and drawers.
   *
   * @param {EventType} eventType - The type of event being registered in the registry, such as "click" or "mousemove".
   * @param {MouseEvent} event - The `event` parameter is of type `MouseEvent`, which represents a
   * mouse-related event (such as a click, double-click, or mouse movement) that occurred on the web
   * page. It contains information about the event, such as the type of event, the target element that
   * triggered the event
   */
  protected callRegistry(eventType: EventType, event: MouseEvent): void;
}
