/**
 * Keyboard key codes.
 */
export declare enum KeyCode {
    Backspace = "Backspace",
    Tab = "Tab",
    Enter = "Enter",
    ShiftRight = "ShiftRight",
    ShiftLeft = "ShiftLeft",
    ControlRight = "ControlRight",
    ControlLeft = "ControlLeft",
    Escape = "Escape",
    AltLeft = "AltLeft",
    AltRight = "AltRight",
    MetaLeft = "MetaLeft",
    MetaRight = "MetaRight",
    Space = "Space",
    ArrowUp = "ArrowUp",
    ArrowDown = "ArrowDown",
    ArrowLeft = "ArrowLeft",
    ArrowRight = "ArrowRight",
    PageUp = "PageUp",
    PageDown = "PageDown",
    End = "End",
    Home = "Home",
    Delete = "Delete",
    Insert = "Insert",
    CapsLock = "CapsLock",
    ScrollLock = "ScrollLock",
    F1 = "F1",
    F2 = "F2",
    F3 = "F3",
    F4 = "F4",
    F5 = "F5",
    F6 = "F6",
    F7 = "F7",
    F8 = "F8",
    F9 = "F9",
    F10 = "F10",
    F11 = "F11",
    F12 = "F12",
    Digit0 = "Digit0",
    Digit1 = "Digit1",
    Digit2 = "Digit2",
    Digit3 = "Digit3",
    Digit4 = "Digit4",
    Digit5 = "Digit5",
    Digit6 = "Digit6",
    Digit7 = "Digit7",
    Digit8 = "Digit8",
    Digit9 = "Digit9",
    Numpad0 = "Numpad0",
    Numpad1 = "Numpad1",
    Numpad2 = "Numpad2",
    Numpad3 = "Numpad3",
    Numpad4 = "Numpad4",
    Numpad5 = "Numpad5",
    Numpad6 = "Numpad6",
    Numpad7 = "Numpad7",
    Numpad8 = "Numpad8",
    Numpad9 = "Numpad9",
    NumpadAdd = "NumpadAdd",
    NumpadDecimal = "NumpadDecimal",
    NumpadDivide = "NumpadDivide",
    NumpadEnter = "NumpadEnter",
    NumpadMultiply = "NumpadMultiply",
    NumpadSubtract = "NumpadSubtract",
    NumLock = "NumLock",
    KeyA = "KeyA",
    KeyB = "KeyB",
    KeyC = "KeyC",
    KeyD = "KeyD",
    KeyE = "KeyE",
    KeyF = "KeyF",
    KeyG = "KeyG",
    KeyH = "KeyH",
    KeyI = "KeyI",
    KeyJ = "KeyJ",
    KeyK = "KeyK",
    KeyL = "KeyL",
    KeyM = "KeyM",
    KeyN = "KeyN",
    KeyO = "KeyO",
    KeyP = "KeyP",
    KeyQ = "KeyQ",
    KeyR = "KeyR",
    KeyS = "KeyS",
    KeyT = "KeyT",
    KeyU = "KeyU",
    KeyV = "KeyV",
    KeyW = "KeyW",
    KeyX = "KeyX",
    KeyY = "KeyY",
    KeyZ = "KeyZ",
    Backquote = "Backquote",
    Minus = "Minus",
    Equal = "Equal",
    Backslash = "Backslash",
    Semicolon = "Semicolon",
    Quote = "Quote",
    Comma = "Comma",
    Period = "Period",
    Slash = "Slash",
    BracketLeft = "BracketLeft",
    BracketRight = "BracketRight"
}
/**
 * Result pair for a key press action containing keydown and keyup events.
 */
export interface KeyPressResult {
    /** Dispatched keydown KeyboardEvent */
    keydown: KeyboardEvent;
    /** Dispatched keyup KeyboardEvent */
    keyup: KeyboardEvent;
}
/**
 * Result of a mouse click action containing mousedown, mouseup, and click events.
 */
export interface MouseClickResult {
    /** Dispatched mousedown event */
    mousedown: MouseEvent;
    /** Dispatched mouseup event */
    mouseup: MouseEvent;
    /** Dispatched click event */
    click: MouseEvent;
}
/**
 * Result of a mouse double-click action containing dispatched mouse events.
 */
export interface MouseDblClickResult {
    /** Dispatched first mousedown event */
    mousedown1: MouseEvent;
    /** Dispatched first mouseup event */
    mouseup1: MouseEvent;
    /** Dispatched first click event */
    click1: MouseEvent;
    /** Dispatched second mousedown event */
    mousedown2: MouseEvent;
    /** Dispatched second mouseup event */
    mouseup2: MouseEvent;
    /** Dispatched second click event */
    click2: MouseEvent;
    /** Dispatched dblclick event */
    dblclick: MouseEvent;
}
/**
 * Result of a mouse hover action containing mouseover and mouseenter events.
 */
export interface MouseHoverResult {
    /** Dispatched mouseover event */
    mouseover: MouseEvent;
    /** Dispatched mouseenter event */
    mouseenter: MouseEvent;
}
/**
 * Result of a mouse leave action containing mouseout and mouseleave events.
 */
export interface MouseLeaveResult {
    /** Dispatched mouseout event */
    mouseout: MouseEvent;
    /** Dispatched mouseleave event */
    mouseleave: MouseEvent;
}
/**
 * Result of an input fill or check action containing input and change events.
 */
export interface FormFieldActionResult {
    /** Dispatched input event */
    inputEvent: Event;
    /** Dispatched change event */
    changeEvent: Event;
}
/**
 * Result of a focus action containing dispatched focus and focusin events.
 */
export interface FocusActionResult {
    /** Dispatched focus event */
    focus: FocusEvent;
    /** Dispatched focusin event */
    focusin: FocusEvent;
}
/**
 * Result of a blur action containing dispatched blur and focusout events.
 */
export interface BlurActionResult {
    /** Dispatched blur event */
    blur: FocusEvent;
    /** Dispatched focusout event */
    focusout: FocusEvent;
}
/**
 * Options for synthetic keyboard press operations.
 */
export interface EventsKeyboardPressOptions extends EventModifierInit {
    /**
     * Time to wait between keydown and keyup in milliseconds. Defaults to 0.
     */
    delay?: number;
}
/**
 * Options for synthetic keyboard typing operations.
 */
export interface EventsKeyboardTypeOptions extends EventModifierInit {
    /**
     * Time to wait between key presses in milliseconds. Defaults to 0.
     */
    delay?: number;
}
/**
 * Synchronous synthetic keyboard event dispatcher for DOM testing.
 *
 * @use when
 * - Fast, synthetic keyboard event dispatching is needed directly on a DOM target.
 * - Simulating key presses, typing, and modifier shortcuts in isolated component tests.
 *
 * @dont use when
 * - Testing OS-level input driver behavior or Playwright actionability checks.
 */
export declare class KeyboardEvents {
    private readonly target;
    /**
     * The default modifier keys and dispatch settings for keyboard events.
     */
    readonly defaultModifierInit: EventModifierInit;
    /**
     * Creates a new instance of the KeyboardEvents class.
     *
     * @param target - The target DOM node for dispatching keyboard events.
     */
    constructor(target: EventTarget);
    /**
     * Private helper to parse key shortcuts, resolve key mapping, and dispatch a KeyboardEvent.
     *
     * @param eventType - Event type string ('keydown' or 'keyup').
     * @param code - The KeyCode, key string, or modifier shortcut.
     * @param init - Optional EventModifierInit overrides.
     * @returns Dispatched KeyboardEvent.
     */
    private dispatch;
    /**
     * Dispatches a synthetic keyboard event `keydown` on the target.
     * Supports modifier shortcut syntax (e.g. `'Control+A'`, `'ControlOrMeta+Shift+Z'`).
     *
     * @param code - The `KeyCode`, key string, or modifier shortcut (e.g. `KeyCode.KeyA`, `'a'`, `'Control+A'`).
     * @param init - Optional `EventModifierInit` overrides.
     * @returns The dispatched keydown `KeyboardEvent`.
     */
    down(code: KeyCode | string, init?: EventModifierInit): KeyboardEvent;
    /**
     * Dispatches a synthetic keyboard event `keyup` on the target.
     * Supports modifier shortcut syntax (e.g. `'Control+A'`, `'ControlOrMeta+Shift+Z'`).
     *
     * @param code - The `KeyCode`, key string, or modifier shortcut (e.g. `KeyCode.KeyA`, `'a'`, `'Control+A'`).
     * @param init - Optional `EventModifierInit` overrides.
     * @returns The dispatched keyup `KeyboardEvent`.
     */
    up(code: KeyCode | string, init?: EventModifierInit): KeyboardEvent;
    /**
     * Dispatches `keydown` followed by `keyup` on the target.
     * Supports modifier shortcut syntax (e.g. `'Control+A'`, `'ControlOrMeta+Shift+Z'`).
     *
     * @param code - The `KeyCode`, key string, or modifier shortcut.
     * @param options - Optional `EventsKeyboardPressOptions` settings.
     * @returns A promise that resolves to an object containing the dispatched `{ keydown, keyup }` events.
     */
    press(code: KeyCode | string, options?: EventsKeyboardPressOptions): Promise<KeyPressResult>;
    /**
     * Sequentially dispatches `keydown` and `keyup` events for each character in text.
     *
     * @param text - The string of characters to type.
     * @param options - Optional `EventsKeyboardTypeOptions` settings.
     * @returns A promise that resolves to an array of dispatched `{ keydown, keyup }` event pairs.
     */
    type(text: string, options?: EventsKeyboardTypeOptions): Promise<KeyPressResult[]>;
}
/**
 * Synchronous synthetic mouse event dispatcher for DOM testing.
 *
 * @use when
 * - Fast, synthetic mouse interactions (click, dblclick, hover, contextMenu) are needed directly on DOM targets.
 * - Testing event listeners in web component or element unit tests.
 *
 * @dont use when
 * - Testing native browser pointer positioning or Playwright actionability checks.
 */
export declare class MouseEvents {
    private readonly target;
    /**
     * Default settings for synthetic mouse events.
     */
    readonly defaultInit: MouseEventInit;
    /**
     * Creates a new instance of the MouseEvents class.
     *
     * @param target - The target DOM node for dispatching mouse events.
     */
    constructor(target: EventTarget);
    /**
     * Private helper to merge defaults and dispatch a MouseEvent.
     *
     * @param type - Event type string (e.g. 'click', 'mousedown').
     * @param options - Optional MouseEventInit overrides.
     * @returns Dispatched MouseEvent.
     */
    private dispatch;
    /**
     * Dispatches a synthetic `mousedown` event on the target.
     *
     * @param options - Optional `MouseEventInit` overrides.
     * @returns Dispatched `MouseEvent`.
     */
    down(options?: MouseEventInit): MouseEvent;
    /**
     * Dispatches a synthetic `mouseup` event on the target.
     *
     * @param options - Optional `MouseEventInit` overrides.
     * @returns Dispatched `MouseEvent`.
     */
    up(options?: MouseEventInit): MouseEvent;
    /**
     * Dispatches a synthetic `mousemove` event on the target.
     *
     * @param options - Optional `MouseEventInit` overrides.
     * @returns Dispatched `MouseEvent`.
     */
    move(options?: MouseEventInit): MouseEvent;
    /**
     * Dispatches `mousedown`, `mouseup`, and `click` events in sequence on the target.
     *
     * @param options - Optional `MouseEventInit` overrides.
     * @returns Object containing the dispatched `{ mousedown, mouseup, click }` events.
     */
    click(options?: MouseEventInit): MouseClickResult;
    /**
     * Dispatches a double-click sequence (`mousedown` -> `mouseup` -> `click` x2 -> `dblclick`) on the target.
     *
     * @param options - Optional `MouseEventInit` overrides.
     * @returns Object containing all dispatched mouse events in the sequence.
     */
    dblclick(options?: MouseEventInit): MouseDblClickResult;
    /**
     * Dispatches a right-click `contextmenu` event on the target.
     *
     * @param options - Optional `MouseEventInit` overrides.
     * @returns Dispatched `MouseEvent`.
     */
    contextMenu(options?: MouseEventInit): MouseEvent;
    /**
     * Dispatches `mouseover` and `mouseenter` events on the target.
     *
     * @param options - Optional `MouseEventInit` overrides.
     * @returns Object containing dispatched `{ mouseover, mouseenter }` events.
     */
    hover(options?: MouseEventInit): MouseHoverResult;
    /**
     * Dispatches `mouseout` and `mouseleave` events on the target.
     *
     * @param options - Optional `MouseEventInit` overrides.
     * @returns Object containing dispatched `{ mouseout, mouseleave }` events.
     */
    leave(options?: MouseEventInit): MouseLeaveResult;
}
/**
 * Synchronous synthetic input and form control event dispatcher for DOM testing.
 *
 * @use when
 * - Fast, synthetic form control interactions (fill, check, uncheck, select) are needed directly on DOM targets.
 * - Triggering `input` and `change` event handlers in framework tests (React, Vue, Lit, Web Components).
 *
 * @dont use when
 * - Testing native browser auto-actionability checks or Playwright form fill commands.
 */
export declare class InputEvents {
    private readonly target;
    /**
     * Creates a new instance of the InputEvents class.
     *
     * @param target - The target DOM node for dispatching input events.
     */
    constructor(target: EventTarget);
    /**
     * Dispatches a synthetic `input` event on the target.
     *
     * @param options - Optional `EventInit` overrides.
     * @returns Dispatched input `Event`.
     */
    emitInput(options?: EventInit): Event;
    /**
     * Dispatches a synthetic `change` event on the target.
     *
     * @param options - Optional `EventInit` overrides.
     * @returns Dispatched change `Event`.
     */
    emitChange(options?: EventInit): Event;
    /**
     * Sets the value of an input or textarea element and dispatches `input` and `change` events.
     *
     * @param value - The text value to set.
     * @param options - Optional `EventInit` overrides for the dispatched events.
     * @returns Object containing the dispatched `{ inputEvent, changeEvent }`.
     */
    fill(value: string, options?: EventInit): FormFieldActionResult;
    /**
     * Sets `checked = true` on a checkbox or radio element and dispatches `input` and `change` events.
     *
     * @param options - Optional `EventInit` overrides.
     * @returns Object containing the dispatched `{ inputEvent, changeEvent }`.
     */
    check(options?: EventInit): FormFieldActionResult;
    /**
     * Sets `checked = false` on a checkbox element and dispatches `input` and `change` events.
     *
     * @param options - Optional `EventInit` overrides.
     * @returns Object containing the dispatched `{ inputEvent, changeEvent }`.
     */
    uncheck(options?: EventInit): FormFieldActionResult;
    /**
     * Toggles the `checked` property on a checkbox element and dispatches `input` and `change` events.
     *
     * @param options - Optional `EventInit` overrides.
     * @returns Object containing the dispatched `{ inputEvent, changeEvent }`.
     */
    toggle(options?: EventInit): FormFieldActionResult;
    /**
     * Sets the value of a `<select>` element and dispatches a `change` event.
     *
     * @param value - The value string to select.
     * @param options - Optional `EventInit` overrides.
     * @returns Dispatched change `Event`.
     */
    selectOption(value: string, options?: EventInit): Event;
}
/**
 * Synchronous synthetic clipboard event dispatcher for DOM testing.
 *
 * @use when
 * - Fast synthetic paste, copy, or cut event dispatching is required directly on DOM targets.
 * - Testing paste handlers in custom input components, text editors, or web components.
 *
 * @dont use when
 * - Testing native OS system clipboard interactions.
 */
export declare class ClipboardEvents {
    private readonly target;
    /**
     * Default settings for synthetic clipboard events.
     */
    readonly defaultInit: ClipboardEventInit;
    /**
     * Creates a new instance of the ClipboardEvents class.
     *
     * @param target - The target DOM node for dispatching clipboard events.
     */
    constructor(target: EventTarget);
    /**
     * Dispatches a synthetic `paste` event on the target populated with a DataTransfer object.
     *
     * @param data - Text string to paste or map of MIME types to string payloads (e.g. `{ 'text/plain': 'Hello' }`).
     * @param options - Optional `ClipboardEventInit` overrides.
     * @returns Dispatched `ClipboardEvent`.
     */
    paste(data: string | Record<string, string>, options?: ClipboardEventInit): ClipboardEvent;
    /**
     * Dispatches a synthetic `copy` event on the target.
     *
     * @param data - Optional data payload to populate in the clipboard event's `clipboardData`.
     * @param options - Optional `ClipboardEventInit` overrides.
     * @returns Dispatched `ClipboardEvent`.
     */
    copy(data?: string | Record<string, string>, options?: ClipboardEventInit): ClipboardEvent;
    /**
     * Dispatches a synthetic `cut` event on the target.
     *
     * @param data - Optional data payload to populate in the clipboard event's `clipboardData`.
     * @param options - Optional `ClipboardEventInit` overrides.
     * @returns Dispatched `ClipboardEvent`.
     */
    cut(data?: string | Record<string, string>, options?: ClipboardEventInit): ClipboardEvent;
}
/**
 * Synchronous synthetic focus and blur event dispatcher for DOM testing.
 *
 * @use when
 * - Fast synthetic focus and blur event dispatching is needed directly on DOM targets.
 * - Testing focus traps, accessibility focus handlers, or blur validation in web components.
 *
 * @dont use when
 * - Testing native OS or window-level browser focus switching.
 */
export declare class FocusEvents {
    private readonly target;
    /**
     * Creates a new instance of the FocusEvents class.
     *
     * @param target - The target DOM node for dispatching focus/blur events.
     */
    constructor(target: EventTarget);
    /**
     * Triggers focus on the target, calling `.focus()` if available and dispatching `focus` and `focusin` events.
     *
     * @param options - Optional `FocusEventInit` overrides.
     * @returns Object containing dispatched `{ focus, focusin }` events.
     */
    in(options?: FocusEventInit): FocusActionResult;
    /**
     * Triggers blur on the target, calling `.blur()` if available and dispatching `blur` and `focusout` events.
     *
     * @param options - Optional `FocusEventInit` overrides.
     * @returns Object containing dispatched `{ blur, focusout }` events.
     */
    out(options?: FocusEventInit): BlurActionResult;
    /**
     * Alias for `in()` - triggers focus on the target and dispatches focus/focusin events.
     *
     * @param options - Optional `FocusEventInit` overrides.
     * @returns Object containing dispatched `{ focus, focusin }` events.
     */
    focus(options?: FocusEventInit): FocusActionResult;
    /**
     * Alias for `out()` - triggers blur on the target and dispatches blur/focusout events.
     *
     * @param options - Optional `FocusEventInit` overrides.
     * @returns Object containing dispatched `{ blur, focusout }` events.
     */
    blur(options?: FocusEventInit): BlurActionResult;
}
/**
 * Synthetic event dispatcher for browser DOM testing.
 *
 * @use when
 * - Fast event dispatching is required without Playwright IPC overhead.
 * - Testing event handlers in isolated web components or DOM subtrees.
 *
 * @dont use when
 * - Testing native browser behaviors that depend on OS-level input drivers or Playwright actionability checks.
 *
 * @example
 * ```typescript
 * import { events, KeyCode } from '@pawel-up/lupa/commands'
 *
 * const input = document.querySelector('input')!
 * events(input).focus.in()
 * events(input).input.fill('Hello World')
 * events(input).clipboard.paste('Pasted Text')
 * await events(input).keyboard.press('Enter')
 * events(input).focus.out()
 * ```
 */
export declare class Events {
    /**
     * Synthetic keyboard event helper.
     */
    readonly keyboard: KeyboardEvents;
    /**
     * Synthetic mouse event helper.
     */
    readonly mouse: MouseEvents;
    /**
     * Synthetic input/form control event helper.
     */
    readonly input: InputEvents;
    /**
     * Synthetic clipboard event helper.
     */
    readonly clipboard: ClipboardEvents;
    /**
     * Synthetic focus and blur event helper.
     */
    readonly focus: FocusEvents;
    /**
     * Creates a new instance of the Events class.
     *
     * @param target - The target DOM node for dispatching synthetic events.
     */
    constructor(target: EventTarget);
}
/**
 * Creates an `Events` instance to dispatch synthetic events on a target DOM node.
 *
 * @param target - The target DOM node for dispatching synthetic events.
 * @returns An `Events` instance.
 */
export declare function events(target: EventTarget): Events;