import { DOMException } from '@gjsify/dom-exception';
export { DOMException };
type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
interface EventListener {
    (evt: Event): void;
}
interface EventListenerObject {
    handleEvent(evt: Event): void;
}
interface AddEventListenerOptions extends EventListenerOptions {
    once?: boolean;
    passive?: boolean;
    signal?: AbortSignal;
}
interface EventListenerOptions {
    capture?: boolean;
}
interface EventInit {
    bubbles?: boolean;
    cancelable?: boolean;
    composed?: boolean;
}
interface CustomEventInit<T = any> extends EventInit {
    detail?: T;
}
declare const kType: unique symbol;
declare const kBubbles: unique symbol;
declare const kCancelable: unique symbol;
declare const kComposed: unique symbol;
declare const kTarget: unique symbol;
declare const kCurrentTarget: unique symbol;
declare const kEventPhase: unique symbol;
declare const kDefaultPrevented: unique symbol;
declare const kIsTrusted: unique symbol;
declare const kTimeStamp: unique symbol;
declare const kStop: unique symbol;
declare const kImmediateStop: unique symbol;
declare const kDispatching: unique symbol;
declare const kInPassiveListener: unique symbol;
export declare class Event {
    private [kType];
    private [kBubbles];
    private [kCancelable];
    private [kComposed];
    private [kTarget];
    private [kCurrentTarget];
    private [kEventPhase];
    private [kDefaultPrevented];
    private [kIsTrusted];
    private [kTimeStamp];
    private [kStop];
    private [kImmediateStop];
    private [kDispatching];
    private [kInPassiveListener];
    get type(): string;
    get bubbles(): boolean;
    get cancelable(): boolean;
    get composed(): boolean;
    get target(): EventTarget | null;
    get currentTarget(): EventTarget | null;
    get eventPhase(): number;
    get defaultPrevented(): boolean;
    readonly isTrusted: boolean;
    get timeStamp(): number;
    get cancelBubble(): boolean;
    set cancelBubble(value: boolean);
    get returnValue(): boolean;
    set returnValue(value: boolean);
    get srcElement(): EventTarget | null;
    static readonly NONE = 0;
    static readonly CAPTURING_PHASE = 1;
    static readonly AT_TARGET = 2;
    static readonly BUBBLING_PHASE = 3;
    readonly NONE: 0;
    readonly CAPTURING_PHASE: 1;
    readonly AT_TARGET: 2;
    readonly BUBBLING_PHASE: 3;
    get [Symbol.toStringTag](): string;
    constructor(type: string, eventInitDict?: EventInit);
    composedPath(): EventTarget[];
    preventDefault(): void;
    stopPropagation(): void;
    stopImmediatePropagation(): void;
}
export declare class CustomEvent<T = any> extends Event {
    readonly detail: T;
    constructor(type: string, eventInitDict?: CustomEventInit<T>);
}
interface MessageEventInit<T = any> extends EventInit {
    data?: T;
    origin?: string;
    lastEventId?: string;
    source?: EventTarget | null;
    ports?: MessagePort[];
}
export declare class MessageEvent<T = any> extends Event {
    readonly data: T;
    readonly origin: string;
    readonly lastEventId: string;
    readonly source: EventTarget | null;
    readonly ports: readonly MessagePort[];
    constructor(type: string, eventInitDict?: MessageEventInit<T>);
    get [Symbol.toStringTag](): string;
}
interface ErrorEventInit extends EventInit {
    message?: string;
    filename?: string;
    lineno?: number;
    colno?: number;
    error?: unknown;
}
export declare class ErrorEvent extends Event {
    readonly message: string;
    readonly filename: string;
    readonly lineno: number;
    readonly colno: number;
    readonly error: unknown;
    constructor(type: string, eventInitDict?: ErrorEventInit);
    get [Symbol.toStringTag](): string;
}
interface CloseEventInit extends EventInit {
    code?: number;
    reason?: string;
    wasClean?: boolean;
}
export declare class CloseEvent extends Event {
    readonly code: number;
    readonly reason: string;
    readonly wasClean: boolean;
    constructor(type: string, eventInitDict?: CloseEventInit);
    get [Symbol.toStringTag](): string;
}
interface ProgressEventInit extends EventInit {
    lengthComputable?: boolean;
    loaded?: number;
    total?: number;
}
export declare class ProgressEvent extends Event {
    readonly lengthComputable: boolean;
    readonly loaded: number;
    readonly total: number;
    constructor(type: string, eventInitDict?: ProgressEventInit);
    get [Symbol.toStringTag](): string;
}
export declare class EventTarget {
    #private;
    get [Symbol.toStringTag](): string;
    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
    dispatchEvent(event: Event): boolean;
}
interface UIEventInit extends EventInit {
    detail?: number;
    view?: null;
}
export declare class UIEvent extends Event {
    readonly detail: number;
    readonly view: null;
    constructor(type: string, eventInitDict?: UIEventInit);
    get [Symbol.toStringTag](): string;
}
interface MouseEventInit extends UIEventInit {
    altKey?: boolean;
    button?: number;
    buttons?: number;
    clientX?: number;
    clientY?: number;
    ctrlKey?: boolean;
    metaKey?: boolean;
    movementX?: number;
    movementY?: number;
    offsetX?: number;
    offsetY?: number;
    screenX?: number;
    screenY?: number;
    shiftKey?: boolean;
    relatedTarget?: EventTarget | null;
}
export declare class MouseEvent extends UIEvent {
    readonly altKey: boolean;
    readonly button: number;
    readonly buttons: number;
    readonly clientX: number;
    readonly clientY: number;
    readonly ctrlKey: boolean;
    readonly metaKey: boolean;
    readonly movementX: number;
    readonly movementY: number;
    readonly offsetX: number;
    readonly offsetY: number;
    readonly screenX: number;
    readonly screenY: number;
    readonly shiftKey: boolean;
    readonly relatedTarget: EventTarget | null;
    get pageX(): number;
    get pageY(): number;
    get x(): number;
    get y(): number;
    constructor(type: string, eventInitDict?: MouseEventInit);
    getModifierState(key: string): boolean;
    get [Symbol.toStringTag](): string;
}
interface PointerEventInit extends MouseEventInit {
    pointerId?: number;
    width?: number;
    height?: number;
    pressure?: number;
    tangentialPressure?: number;
    tiltX?: number;
    tiltY?: number;
    twist?: number;
    altitudeAngle?: number;
    azimuthAngle?: number;
    pointerType?: string;
    isPrimary?: boolean;
}
export declare class PointerEvent extends MouseEvent {
    readonly pointerId: number;
    readonly width: number;
    readonly height: number;
    readonly pressure: number;
    readonly tangentialPressure: number;
    readonly tiltX: number;
    readonly tiltY: number;
    readonly twist: number;
    readonly altitudeAngle: number;
    readonly azimuthAngle: number;
    readonly pointerType: string;
    readonly isPrimary: boolean;
    constructor(type: string, eventInitDict?: PointerEventInit);
    getCoalescedEvents(): PointerEvent[];
    getPredictedEvents(): PointerEvent[];
    get [Symbol.toStringTag](): string;
}
interface KeyboardEventInit extends UIEventInit {
    altKey?: boolean;
    code?: string;
    ctrlKey?: boolean;
    isComposing?: boolean;
    key?: string;
    location?: number;
    metaKey?: boolean;
    repeat?: boolean;
    shiftKey?: boolean;
    keyCode?: number;
    which?: number;
}
export declare class KeyboardEvent extends UIEvent {
    readonly altKey: boolean;
    readonly code: string;
    readonly ctrlKey: boolean;
    readonly isComposing: boolean;
    readonly key: string;
    readonly location: number;
    readonly metaKey: boolean;
    readonly repeat: boolean;
    readonly shiftKey: boolean;
    readonly keyCode: number;
    readonly which: number;
    static readonly DOM_KEY_LOCATION_STANDARD = 0;
    static readonly DOM_KEY_LOCATION_LEFT = 1;
    static readonly DOM_KEY_LOCATION_RIGHT = 2;
    static readonly DOM_KEY_LOCATION_NUMPAD = 3;
    constructor(type: string, eventInitDict?: KeyboardEventInit);
    getModifierState(key: string): boolean;
    get [Symbol.toStringTag](): string;
}
interface WheelEventInit extends MouseEventInit {
    deltaX?: number;
    deltaY?: number;
    deltaZ?: number;
    deltaMode?: number;
}
export declare class WheelEvent extends MouseEvent {
    readonly deltaX: number;
    readonly deltaY: number;
    readonly deltaZ: number;
    readonly deltaMode: number;
    static readonly DOM_DELTA_PIXEL = 0;
    static readonly DOM_DELTA_LINE = 1;
    static readonly DOM_DELTA_PAGE = 2;
    constructor(type: string, eventInitDict?: WheelEventInit);
    get [Symbol.toStringTag](): string;
}
interface FocusEventInit extends UIEventInit {
    relatedTarget?: EventTarget | null;
}
export declare class FocusEvent extends UIEvent {
    readonly relatedTarget: EventTarget | null;
    constructor(type: string, eventInitDict?: FocusEventInit);
    get [Symbol.toStringTag](): string;
}
declare const _default: {
    Event: typeof Event;
    CustomEvent: typeof CustomEvent;
    EventTarget: typeof EventTarget;
    MessageEvent: typeof MessageEvent;
    ErrorEvent: typeof ErrorEvent;
    CloseEvent: typeof CloseEvent;
    ProgressEvent: typeof ProgressEvent;
    UIEvent: typeof UIEvent;
    MouseEvent: typeof MouseEvent;
    PointerEvent: typeof PointerEvent;
    KeyboardEvent: typeof KeyboardEvent;
    WheelEvent: typeof WheelEvent;
    FocusEvent: typeof FocusEvent;
};
export default _default;