import '../../../assert/js/assert.js';
import '../../../tandem/js/PhetioIDUtils.js';
import '../../../globals.js';
import { Node, PressListener, PressListenerOptions, SceneryEvent, TInputListener } from '../imports.js';
type SelfOptions = {
    fire?: (event: SceneryEvent<MouseEvent | TouchEvent | PointerEvent | FocusEvent | KeyboardEvent>) => void;
    fireOnDown?: boolean;
    fireOnHold?: boolean;
    fireOnHoldDelay?: number;
    fireOnHoldInterval?: number;
};
export type FireListenerOptions<Listener extends FireListener> = SelfOptions & PressListenerOptions<Listener>;
export default class FireListener extends PressListener implements TInputListener {
    private _fireOnDown;
    private firedEmitter;
    private _timer?;
    constructor(providedOptions?: FireListenerOptions<FireListener>);
    /**
     * Fires any associated button fire callback.
     *
     * NOTE: This is safe to call on the listener externally.
     */
    fire(event: SceneryEvent<MouseEvent | TouchEvent | PointerEvent | FocusEvent | KeyboardEvent> | null): void;
    /**
     * Presses the button.
     *
     * NOTE: This is safe to call externally in order to attempt to start a press. fireListener.canPress( event ) can
     * be used to determine whether this will actually start a press.
     *
     * @param event
     * @param [targetNode] - If provided, will take the place of the targetNode for this call. Useful for
     *                              forwarded presses.
     * @param [callback] - to be run at the end of the function, but only on success
     * @returns success - Returns whether the press was actually started
     */
    press(event: SceneryEvent<MouseEvent | TouchEvent | PointerEvent | FocusEvent | KeyboardEvent>, targetNode?: Node, callback?: () => void): boolean;
    /**
     * Releases the button.
     *
     * NOTE: This can be safely called externally in order to force a release of this button (no actual 'up' event is
     * needed). If the cancel/interrupt behavior is more preferable (will not fire the button), then call interrupt()
     * on this listener instead.
     *
     * @param [event] - scenery event if there was one
     * @param [callback] - called at the end of the release
     */
    release(event?: SceneryEvent<MouseEvent | TouchEvent | PointerEvent | FocusEvent | KeyboardEvent>, callback?: () => void): void;
    /**
     * Clicks the listener, pressing it and releasing it immediately. Part of the scenery input API, triggered from PDOM
     * events for accessibility.
     *
     * Click does not involve the FireListener timer because it is a discrete event that
     * presses and releases the listener immediately. This behavior is a limitation imposed
     * by screen reader technology. See PressListener.click for more information.
     *
     * NOTE: This can be safely called externally in order to click the listener, event is not required.
     * fireListener.canClick() can be used to determine if this will actually trigger a click.
     *
     * @param [event]
     * @param [callback] - called at the end of the click
     */
    click(event: SceneryEvent<MouseEvent> | null, callback?: () => void): boolean;
    /**
     * Interrupts the listener, releasing it (canceling behavior).
     *
     * This effectively releases/ends the press, and sets the `interrupted` flag to true while firing these events
     * so that code can determine whether a release/end happened naturally, or was canceled in some way.
     *
     * This can be called manually, but can also be called through node.interruptSubtreeInput().
     */
    interrupt(): void;
    dispose(): void;
}
export {};
//# sourceMappingURL=FireListener.d.ts.map