import type { EventTarget, HandlerObject } from './store';
import { EventObject } from './object';
import { EventHandler } from './types';
export declare function get(type: string): EventHook;
export declare function register(type: string, hook: EventHook): void;
export declare function unregister(type: string): void;
export interface EventHook {
    /**
     * Indicates whether this event type should be bubbled when the `.trigger()`
     * method is called; by default it is `false`, meaning that a triggered event
     * will bubble to the element's parents up to the document (if attached to a
     * document) and then to the window. Note that defining `noBubble` on an event
     * will effectively prevent that event from being used for delegated events
     * with `.trigger()`.
     */
    noBubble?: boolean;
    /**
     * When defined, these string properties specify that a special event should
     * be handled like another event type until the event is delivered.
     *
     * The `bindType` is used if the event is attached directly, and the
     * `delegateType` is used for delegated events. These types are generally DOM
     * event types, and should not be a special event themselves.
     */
    bindType?: string;
    /**
     * When defined, these string properties specify that a special event should
     * be handled like another event type until the event is delivered.
     *
     * The `bindType` is used if the event is attached directly, and the
     * `delegateType` is used for delegated events. These types are generally DOM
     * event types, and should not be a special event themselves.
     */
    delegateType?: string;
    /**
     * The setup hook is called the first time an event of a particular type is
     * attached to an element; this provides the hook an opportunity to do
     * processing that will apply to all events of this type on the element.
     *
     * The `elem` is the reference to the element where the event is being
     * attached and `eventHandle` is the event handler function. In most cases
     * the `namespaces` argument should not be used, since it only represents the
     * namespaces of the first event being attached; subsequent events may not
     * have this same namespaces.
     *
     * This hook can perform whatever processing it desires, including attaching
     * its own event handlers to the element or to other elements and recording
     * setup information on the element using the `.data()` method. If the
     * setup hook wants me to add a browser event (via `addEventListener` or
     * `attachEvent`, depending on browser) it should return `false`. In all
     * other cases, me will not add the browser event, but will continue all its
     * other bookkeeping for the event. This would be appropriate, for example,
     * if the event was never fired by the browser but invoked by `.trigger()`.
     * To attach the me event handler in the setup hook, use the `eventHandle`
     * argument.
     *
     */
    setup?: (elem: EventTarget, data: any, namespaces: string[], eventHandle: EventHandler<EventTarget, any>) => any | false;
    /**
     * The teardown hook is called when the final event of a particular type is
     * removed from an element. The `elem` is the reference to the element where
     * the event is being cleaned up. This hook should return `false` if it wants
     * me to remove the event from the browser's event system (via
     * `removeEventListener` or `detachEvent`). In most cases, the setup and
     * teardown hooks should return the same value.
     *
     * If the setup hook attached event handlers or added data to an element
     * through a mechanism such as `.data()`, the teardown hook should reverse
     * the process and remove them. me will generally remove the data and events
     * when an element is totally removed from the document, but failing to remove
     * data or events on teardown will cause a memory leak if the element stays in
     * the document.
     *
     */
    teardown?: (elem: EventTarget, namespaces: string[], eventHandle: EventHandler<EventTarget, any>) => any | false;
    /**
     * Each time an event handler is added to an element through an API such as
     * `.on()`, me calls this hook. The `elem` is the element to which the event
     * handler is being added, and the `handleObj` argument is as described in the
     * section above. The return value of this hook is ignored.
     */
    add?: (elem: EventTarget, handleObj: HandlerObject) => void;
    /**
     * When an event handler is removed from an element using an API such as
     * `.off()`, this hook is called. The `elem` is the element where the handler
     * is being removed, and the `handleObj` argument is as described in the
     * section above. The return value of this hook is ignored.
     *
     */
    remove?: (elem: EventTarget, handleObj: HandlerObject) => void;
    /**
     * The handle hook is called when the event has occurred and me would
     * normally call the user's event handler specified by `.on()` or another
     * event binding method. If the hook exists, me calls it instead of that
     * event handler, passing it the event and any data passed from `.trigger()`
     * if it was not a native event. The `elem` argument is the DOM element being
     * handled, and `event.handleObj` property has the detailed event information.
     *
     */
    handle?: (elem: EventTarget, event: EventObject, ...args: any[]) => void;
    /**
     * Called when the `.trigger()` method is used to trigger an event for the
     * special type from code, as opposed to events that originate from within
     * the browser. The `elem` argument will be the element being triggered, and
     * the `event` argument will be a `EventObject` object constructed from the
     * caller's input. At minimum, the event type, data, namespace, and target
     * properties are set on the event. The data argument represents additional
     * data passed by `.trigger()` if present.
     *
     */
    trigger?: (elem: EventTarget, event: EventObject, data: any) => any | false;
    /**
     * When the `.trigger()` method finishes running all the event handlers for
     * an event, it also looks for and runs any method on the target object by
     * the same name unless of the handlers called `event.preventDefault()`. So,
     * `.trigger("submit")` will execute the `submit()` method on the element if
     * one exists. When a `preventDefault` hook is specified, the hook is called
     * just prior to checking for and executing the element's default method. If
     * this hook returns the value `false` the element's default method will be
     * called; otherwise it is not.
     */
    preventDefault?: (elem: EventTarget, event: EventObject, data: any) => any | false;
    preDispatch?: (elem: EventTarget, event: EventObject) => void | false;
    postDispatch?: (elem: EventTarget, event: EventObject) => void;
}