import { type Reference } from "@knyt/artisan";
import type { BasicEvent } from "./BasicEvent.ts";
import type { SyncEventListener } from "./types.ts";
/**
 * @public
 */
export type PropertyChangePayload<P extends string | symbol | number = string, T = unknown> = {
    currentValue: T;
    previousValue: T;
    propertyName: P;
};
/**
 * @public
 */
export type PropertyChangeHandler<P extends string | symbol | number = string, T = unknown> = (args: PropertyChangePayload<P, T>) => void;
/**
 * @public
 */
export type InferPropertyChangePayload<T, P extends keyof T = keyof T> = PropertyChangePayload<P, T[P]>;
/**
 * @public
 */
export type InferPropertyChangeHandler<T, P extends keyof T = keyof T> = PropertyChangeHandler<P, T[P]>;
/**
 * An event emitter that facilitates dispatching events asynchronously.
 *
 * @remarks
 *
 * This class partially implements the interface of native event emitters
 * to dispatch events on both a given event emitter, which is typically a DOM element,
 * and an internal event station asynchronously.
 *
 * The goal is to provide a way to dispatch native-like events asynchronously in a similar manner
 * to the native interfaces facilitating better interoperability.
 */
export declare class BasicEmitter implements BasicEvent.Emitter {
    #private;
    /**
     * @param pairedDispatcher - Another event emitter or a target element to dispatch events on.
     */
    constructor(pairedDispatcher: BasicEmitter.Input);
    /**
     * Dispatch the event on the target element and the event station.
     *
     * If the target element is not set, the event will only be dispatched on the event station.
     *
     * @remarks
     *
     * The event should be defined on `HTMLElementEventMap`.
     *
     * ```ts
     * define global {
     *   interface HTMLElementEventMap {
     *     "custom-event": CustomEvent;
     *   }
     * }
     * ```
     *
     * @see HTMLElementEventMap
     */
    dispatchEvent<T extends HTMLElementEventMap[keyof HTMLElementEventMap]>(customEvent: T): Promise<boolean>;
    /**
     * Add an event listener to the emitter.
     *
     * TODO: Add support for `options.async` to add the listener to the event station.
     */
    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: SyncEventListener<HTMLElementEventMap[K]>, options?: boolean | AddEventListenerOptions): void;
    /**
     * Remove an event listener to the emitter.
     *
     * TODO: Add support for `options.async` to remove the listener to the event station.
     */
    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: SyncEventListener<HTMLElementEventMap[K]>, _options?: boolean | EventListenerOptions): void;
    replaceEventListener<K extends keyof HTMLElementEventMap>(type: K, listenerPair: readonly [
        prevListener: SyncEventListener<HTMLElementEventMap[K]> | undefined,
        nextListener: SyncEventListener<HTMLElementEventMap[K]> | undefined
    ], options?: boolean | AddEventListenerOptions): void;
    /**
     * Creates a property change handler that replaces the event listener for the associated DOM event.
     *
     * @remarks
     *
     * This can be used as a standalone function.
     *
     * @deprecated
     */
    createEventListenerPropertyChangeHandler: <T, P extends keyof T = keyof T, K extends keyof HTMLElementEventMap = keyof HTMLElementEventMap>(domEventNameByPropertyName: Partial<Record<P, K>>) => InferPropertyChangeHandler<T, P>;
}
export declare namespace BasicEmitter {
    type Input = null | Reference.Maybe<BasicEvent.Dispatcher>;
}
//# sourceMappingURL=BasicEmitter.d.ts.map