@angular/aria 21.1.0-next.2 → 21.1.0-next.3

package/types/_list-chunk.d.ts

@@ -1,4 +1,3 @@
-import * as _angular_core from '@angular/core';
 import { ListFocusItem, SignalLike, ListFocusInputs, WritableSignalLike, ListFocus, ListNavigationItem, ListNavigationInputs, ListNavigation } from './_list-navigation-chunk.js';
 
 /** Represents an item in a collection, such as a listbox option, that can be selected. */
@@ -23,11 +22,11 @@ declare class ListSelection<T extends ListSelectionItem<V>, V> {
         focusManager: ListFocus<T>;
     };
     /** The start index to use for range selection. */
-    rangeStartIndex: _angular_core.WritableSignal<number>;
+    rangeStartIndex: WritableSignalLike<number>;
     /** The end index to use for range selection. */
-    rangeEndIndex: _angular_core.WritableSignal<number>;
+    rangeEndIndex: WritableSignalLike<number>;
     /** The currently selected items. */
-    selectedItems: _angular_core.Signal<T[]>;
+    selectedItems: SignalLike<T[]>;
     constructor(inputs: ListSelectionInputs<T, V> & {
         focusManager: ListFocus<T>;
     });
@@ -93,7 +92,7 @@ declare class ListTypeahead<T extends ListTypeaheadItem> {
     /** The focus controller of the parent list. */
     focusManager: ListFocus<T>;
     /** Whether the user is actively typing a typeahead search query. */
-    isTyping: _angular_core.Signal<boolean>;
+    isTyping: SignalLike<boolean>;
     /** Keeps track of the characters that typeahead search is being called with. */
     private _query;
     /** The index where that the typeahead search was initiated from. */
@@ -135,13 +134,13 @@ declare class List<T extends ListItem<V>, V> {
     /** Controls focus for the list. */
     focusBehavior: ListFocus<T>;
     /** Whether the list is disabled. */
-    disabled: _angular_core.Signal<boolean>;
+    disabled: SignalLike<boolean>;
     /** The id of the current active item. */
-    activeDescendant: _angular_core.Signal<string | undefined>;
+    activeDescendant: SignalLike<string | undefined>;
     /** The tab index of the list. */
-    tabIndex: _angular_core.Signal<0 | -1>;
+    tabIndex: SignalLike<0 | -1>;
     /** The index of the currently active item in the list. */
-    activeIndex: _angular_core.Signal<number>;
+    activeIndex: SignalLike<number>;
     /**
      * The uncommitted index for selecting a range of options.
      *

package/types/_list-navigation-chunk.d.ts

@@ -1,107 +1,14 @@
-import * as _angular_core from '@angular/core';
-
-/**
- * Options that are applicable to all event handlers.
- *
- * This library has not yet had a need for stopPropagationImmediate.
- */
-interface EventHandlerOptions {
-    stopPropagation: boolean;
-    preventDefault: boolean;
-}
-/** A basic event handler. */
-type EventHandler<T extends Event> = (event: T) => void;
-/** A function that determines whether an event is to be handled. */
-type EventMatcher<T extends Event> = (event: T) => boolean;
-/** A config that specifies how to handle a particular event. */
-interface EventHandlerConfig<T extends Event> extends EventHandlerOptions {
-    matcher: EventMatcher<T>;
-    handler: EventHandler<T>;
-}
-/** Bit flag representation of the possible modifier keys that can be present on an event. */
-declare enum Modifier {
-    None = 0,
-    Ctrl = 1,
-    Shift = 2,
-    Alt = 4,
-    Meta = 8,
-    Any = "Any"
-}
-type ModifierInputs = Modifier | Modifier[];
-/**
- * Abstract base class for all event managers.
- *
- * Event managers are designed to normalize how event handlers are authored and create a safety net
- * for common event handling gotchas like remembering to call preventDefault or stopPropagation.
- */
-declare abstract class EventManager<T extends Event> {
-    protected configs: EventHandlerConfig<T>[];
-    abstract options: EventHandlerOptions;
-    /** Runs the handlers that match with the given event. */
-    handle(event: T): void;
-    /** Configures the event manager to handle specific events. (See subclasses for more). */
-    abstract on(...args: [...unknown[]]): this;
-}
-
 type SignalLike<T> = () => T;
 interface WritableSignalLike<T> extends SignalLike<T> {
     set(value: T): void;
     update(updateFn: (value: T) => T): void;
+    asReadonly(): SignalLike<T>;
 }
 /** Converts a getter setter style signal to a WritableSignalLike. */
 declare function convertGetterSetterToWritableSignalLike<T>(getter: () => T, setter: (v: T) => void): WritableSignalLike<T>;
-
-/**
- * Used to represent a keycode.
- *
- * This is used to match whether an events keycode should be handled. The ability to match using a
- * string, SignalLike, or Regexp gives us more flexibility when authoring event handlers.
- */
-type KeyCode = string | SignalLike<string> | RegExp;
-/**
- * An event manager that is specialized for handling keyboard events. By default this manager stops
- * propagation and prevents default on all events it handles.
- */
-declare class KeyboardEventManager<T extends KeyboardEvent> extends EventManager<T> {
-    options: EventHandlerOptions;
-    /** Configures this event manager to handle events with a specific key and no modifiers. */
-    on(key: KeyCode, handler: EventHandler<T>, options?: Partial<EventHandlerOptions>): this;
-    /**  Configures this event manager to handle events with a specific modifer and key combination. */
-    on(modifiers: ModifierInputs, key: KeyCode, handler: EventHandler<T>, options?: Partial<EventHandlerOptions>): this;
-    private _normalizeInputs;
-    private _isMatch;
-}
-
-/**
- * The different mouse buttons that may appear on a pointer event.
- */
-declare enum MouseButton {
-    Main = 0,
-    Auxiliary = 1,
-    Secondary = 2
-}
-/** An event manager that is specialized for handling pointer events. */
-declare class PointerEventManager<T extends PointerEvent> extends EventManager<T> {
-    options: EventHandlerOptions;
-    /**
-     * Configures this event manager to handle events with a specific modifer and mouse button
-     * combination.
-     */
-    on(button: MouseButton, modifiers: ModifierInputs, handler: EventHandler<T>): this;
-    /**
-     * Configures this event manager to handle events with a specific mouse button and no modifiers.
-     */
-    on(modifiers: ModifierInputs, handler: EventHandler<T>): this;
-    /**
-     * Configures this event manager to handle events with the main mouse button and no modifiers.
-     *
-     * @param handler The handler function
-     * @param options Options for whether to stop propagation or prevent default.
-     */
-    on(handler: EventHandler<T>): this;
-    private _normalizeInputs;
-    _isMatch(event: PointerEvent, button: MouseButton, modifiers: ModifierInputs): boolean;
-}
+declare function computed<T>(computation: () => T): SignalLike<T>;
+declare function signal<T>(initialValue: T): WritableSignalLike<T>;
+declare function linkedSignal<T>(sourceFn: () => T): WritableSignalLike<T>;
 
 /** Represents an item in a collection, such as a listbox option, than may receive focus. */
 interface ListFocusItem {
@@ -132,11 +39,11 @@ interface ListFocusInputs<T extends ListFocusItem> {
 declare class ListFocus<T extends ListFocusItem> {
     readonly inputs: ListFocusInputs<T>;
     /** The last item that was active. */
-    prevActiveItem: _angular_core.WritableSignal<T | undefined>;
+    prevActiveItem: WritableSignalLike<T | undefined>;
     /** The index of the last item that was active. */
-    prevActiveIndex: _angular_core.Signal<number>;
+    prevActiveIndex: SignalLike<number>;
     /** The current active index in the list. */
-    activeIndex: _angular_core.Signal<number>;
+    activeIndex: SignalLike<number>;
     constructor(inputs: ListFocusInputs<T>);
     /** Whether the list is in a disabled state. */
     isListDisabled(): boolean;
@@ -208,5 +115,5 @@ declare class ListNavigation<T extends ListNavigationItem> {
     private _peek;
 }
 
-export { KeyboardEventManager, ListFocus, ListNavigation, PointerEventManager, convertGetterSetterToWritableSignalLike };
+export { ListFocus, ListNavigation, computed, convertGetterSetterToWritableSignalLike, linkedSignal, signal };
 export type { ListFocusInputs, ListFocusItem, ListNavigationInputs, ListNavigationItem, SignalLike, WritableSignalLike };

package/types/_listbox-chunk.d.ts

@@ -1,6 +1,7 @@
-import * as _angular_core from '@angular/core';
-import { SignalLike, KeyboardEventManager, PointerEventManager } from './_list-navigation-chunk.js';
+import { SignalLike, WritableSignalLike } from './_list-navigation-chunk.js';
 import { ListItem, ListInputs, List } from './_list-chunk.js';
+import { KeyboardEventManager } from './_keyboard-event-manager-chunk.js';
+import { PointerEventManager } from './_pointer-event-manager-chunk.js';
 
 /**
  * Represents the properties exposed by a listbox that need to be accessed by an option.
@@ -21,11 +22,11 @@ declare class OptionPattern<V> {
     /** The value of the option. */
     value: SignalLike<V>;
     /** The position of the option in the list. */
-    index: _angular_core.Signal<number>;
+    index: SignalLike<number>;
     /** Whether the option is active. */
-    active: _angular_core.Signal<boolean>;
+    active: SignalLike<boolean>;
     /** Whether the option is selected. */
-    selected: _angular_core.Signal<boolean | undefined>;
+    selected: SignalLike<boolean | undefined>;
     /** Whether the option is selectable. */
     selectable: () => boolean;
     /** Whether the option is disabled. */
@@ -35,7 +36,7 @@ declare class OptionPattern<V> {
     /** A reference to the parent listbox. */
     listbox: SignalLike<ListboxPattern$1<V> | undefined>;
     /** The tab index of the option. */
-    tabIndex: _angular_core.Signal<0 | -1 | undefined>;
+    tabIndex: SignalLike<0 | -1 | undefined>;
     /** The html element that should receive focus. */
     element: SignalLike<HTMLElement | undefined>;
     constructor(args: OptionInputs<V>);
@@ -55,33 +56,33 @@ declare class ListboxPattern<V> {
     /** Whether the list is vertically or horizontally oriented. */
     orientation: SignalLike<'vertical' | 'horizontal'>;
     /** Whether the listbox is disabled. */
-    disabled: _angular_core.Signal<boolean>;
+    disabled: SignalLike<boolean>;
     /** Whether the listbox is readonly. */
     readonly: SignalLike<boolean>;
     /** The tab index of the listbox. */
     tabIndex: SignalLike<-1 | 0>;
     /** The id of the current active item. */
-    activeDescendant: _angular_core.Signal<string | undefined>;
+    activeDescendant: SignalLike<string | undefined>;
     /** Whether multiple items in the list can be selected at once. */
     multi: SignalLike<boolean>;
     /** The number of items in the listbox. */
-    setsize: _angular_core.Signal<number>;
+    setsize: SignalLike<number>;
     /** Whether the listbox selection follows focus. */
-    followFocus: _angular_core.Signal<boolean>;
+    followFocus: SignalLike<boolean>;
     /** Whether the listbox should wrap. Used to disable wrapping while range selecting. */
-    wrap: _angular_core.WritableSignal<boolean>;
+    wrap: WritableSignalLike<boolean>;
     /** The key used to navigate to the previous item in the list. */
-    prevKey: _angular_core.Signal<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
+    prevKey: SignalLike<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
     /** The key used to navigate to the next item in the list. */
-    nextKey: _angular_core.Signal<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
+    nextKey: SignalLike<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
     /** Represents the space key. Does nothing when the user is actively using typeahead. */
-    dynamicSpaceKey: _angular_core.Signal<"" | " ">;
+    dynamicSpaceKey: SignalLike<"" | " ">;
     /** The regexp used to decide if a key should trigger typeahead. */
     typeaheadRegexp: RegExp;
     /** The keydown event manager for the listbox. */
-    keydown: _angular_core.Signal<KeyboardEventManager<KeyboardEvent>>;
+    keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
     /** The pointerdown event manager for the listbox. */
-    pointerdown: _angular_core.Signal<PointerEventManager<PointerEvent>>;
+    pointerdown: SignalLike<PointerEventManager<PointerEvent>>;
     constructor(inputs: ListboxInputs<V>);
     /** Returns a set of violations */
     validate(): string[];

package/types/_menu-chunk.d.ts

@@ -0,0 +1,267 @@
+import { SignalLike, WritableSignalLike } from './_list-navigation-chunk.js';
+import { KeyboardEventManager } from './_keyboard-event-manager-chunk.js';
+import { ListInputs, ListItem, List } from './_list-chunk.js';
+
+/** The inputs for the MenuBarPattern class. */
+interface MenuBarInputs<V> extends ListInputs<MenuItemPattern<V>, V> {
+    /** The menu items contained in the menu. */
+    items: SignalLike<MenuItemPattern<V>[]>;
+    /** Callback function triggered when a menu item is selected. */
+    onSelect?: (value: V) => void;
+    /** The text direction of the menu bar. */
+    textDirection: SignalLike<'ltr' | 'rtl'>;
+}
+/** The inputs for the MenuPattern class. */
+interface MenuInputs<V> extends Omit<ListInputs<MenuItemPattern<V>, V>, 'values'> {
+    /** The unique ID of the menu. */
+    id: SignalLike<string>;
+    /** The menu items contained in the menu. */
+    items: SignalLike<MenuItemPattern<V>[]>;
+    /** A reference to the parent menu or menu trigger. */
+    parent: SignalLike<MenuTriggerPattern<V> | MenuItemPattern<V> | undefined>;
+    /** Callback function triggered when a menu item is selected. */
+    onSelect?: (value: V) => void;
+    /** The text direction of the menu bar. */
+    textDirection: SignalLike<'ltr' | 'rtl'>;
+    /** The delay in milliseconds before expanding sub-menus on hover. */
+    expansionDelay: SignalLike<number>;
+}
+/** The inputs for the MenuTriggerPattern class. */
+interface MenuTriggerInputs<V> {
+    /** A reference to the menu trigger element. */
+    element: SignalLike<HTMLElement | undefined>;
+    /** A reference to the menu associated with the trigger. */
+    menu: SignalLike<MenuPattern<V> | undefined>;
+    /** The text direction of the menu bar. */
+    textDirection: SignalLike<'ltr' | 'rtl'>;
+    /** Whether the menu trigger is disabled. */
+    disabled: SignalLike<boolean>;
+}
+/** The inputs for the MenuItemPattern class. */
+interface MenuItemInputs<V> extends Omit<ListItem<V>, 'index' | 'selectable'> {
+    /** A reference to the parent menu or menu trigger. */
+    parent: SignalLike<MenuPattern<V> | MenuBarPattern<V> | undefined>;
+    /** A reference to the submenu associated with the menu item. */
+    submenu: SignalLike<MenuPattern<V> | undefined>;
+}
+/** The menu ui pattern class. */
+declare class MenuPattern<V> {
+    readonly inputs: MenuInputs<V>;
+    /** The unique ID of the menu. */
+    id: SignalLike<string>;
+    /** The role of the menu. */
+    role: () => string;
+    /** Whether the menu is disabled. */
+    disabled: () => boolean;
+    /** Whether the menu is visible. */
+    visible: SignalLike<boolean>;
+    /** Controls list behavior for the menu items. */
+    listBehavior: List<MenuItemPattern<V>, V>;
+    /** Whether the menu or any of its child elements are currently focused. */
+    isFocused: WritableSignalLike<boolean>;
+    /** Whether the menu has received focus. */
+    hasBeenFocused: WritableSignalLike<boolean>;
+    /** Whether the menu trigger has been hovered. */
+    hasBeenHovered: WritableSignalLike<boolean>;
+    /** Timeout used to open sub-menus on hover. */
+    _openTimeout: any;
+    /** Timeout used to close sub-menus on hover out. */
+    _closeTimeout: any;
+    /** The tab index of the menu. */
+    tabIndex: () => 0 | -1;
+    /** Whether the menu should be focused on mouse over. */
+    shouldFocus: SignalLike<boolean>;
+    /** The key used to expand sub-menus. */
+    private _expandKey;
+    /** The key used to collapse sub-menus. */
+    private _collapseKey;
+    /** Represents the space key. Does nothing when the user is actively using typeahead. */
+    dynamicSpaceKey: SignalLike<"" | " ">;
+    /** The regexp used to decide if a key should trigger typeahead. */
+    typeaheadRegexp: RegExp;
+    /** The root of the menu. */
+    root: SignalLike<MenuTriggerPattern<V> | MenuBarPattern<V> | MenuPattern<V> | undefined>;
+    /** Handles keyboard events for the menu. */
+    keydownManager: SignalLike<KeyboardEventManager<KeyboardEvent>>;
+    constructor(inputs: MenuInputs<V>);
+    /** Sets the default state for the menu. */
+    setDefaultState(): void;
+    /** Handles keyboard events for the menu. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Handles mouseover events for the menu. */
+    onMouseOver(event: MouseEvent): void;
+    /** Closes the specified menu item after a delay. */
+    private _closeItem;
+    /** Opens the specified menu item after a delay. */
+    private _openItem;
+    /** Handles mouseout events for the menu. */
+    onMouseOut(event: MouseEvent): void;
+    /** Handles click events for the menu. */
+    onClick(event: MouseEvent): void;
+    /** Handles focusin events for the menu. */
+    onFocusIn(): void;
+    /** Handles the focusout event for the menu. */
+    onFocusOut(event: FocusEvent): void;
+    /** Focuses the previous menu item. */
+    prev(): void;
+    /** Focuses the next menu item. */
+    next(): void;
+    /** Focuses the first menu item. */
+    first(): void;
+    /** Focuses the last menu item. */
+    last(): void;
+    /** Triggers the active menu item. */
+    trigger(): void;
+    /** Submits the menu. */
+    submit(item?: MenuItemPattern<V> | undefined): void;
+    /** Collapses the current menu or focuses the previous item in the menubar. */
+    collapse(): void;
+    /** Expands the current menu or focuses the next item in the menubar. */
+    expand(): void;
+    /** Closes the menu. */
+    close(): void;
+    /** Closes the menu and all parent menus. */
+    closeAll(): void;
+    /** Clears any open or close timeouts for sub-menus. */
+    _clearTimeouts(): void;
+    /** Clears the open timeout. */
+    _clearOpenTimeout(): void;
+    /** Clears the close timeout. */
+    _clearCloseTimeout(): void;
+}
+/** The menubar ui pattern class. */
+declare class MenuBarPattern<V> {
+    readonly inputs: MenuBarInputs<V>;
+    /** Controls list behavior for the menu items. */
+    listBehavior: List<MenuItemPattern<V>, V>;
+    /** The tab index of the menu. */
+    tabIndex: () => 0 | -1;
+    /** The key used to navigate to the next item. */
+    private _nextKey;
+    /** The key used to navigate to the previous item. */
+    private _previousKey;
+    /** Represents the space key. Does nothing when the user is actively using typeahead. */
+    dynamicSpaceKey: SignalLike<"" | " ">;
+    /** The regexp used to decide if a key should trigger typeahead. */
+    typeaheadRegexp: RegExp;
+    /** Whether the menubar or any of its children are currently focused. */
+    isFocused: WritableSignalLike<boolean>;
+    /** Whether the menubar has been focused. */
+    hasBeenFocused: WritableSignalLike<boolean>;
+    /** Whether the menubar is disabled. */
+    disabled: () => boolean;
+    /** Handles keyboard events for the menu. */
+    keydownManager: SignalLike<KeyboardEventManager<KeyboardEvent>>;
+    constructor(inputs: MenuBarInputs<V>);
+    /** Sets the default state for the menubar. */
+    setDefaultState(): void;
+    /** Handles keyboard events for the menu. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Handles click events for the menu bar. */
+    onClick(event: MouseEvent): void;
+    /** Handles mouseover events for the menu bar. */
+    onMouseOver(event: MouseEvent): void;
+    /** Handles focusin events for the menu bar. */
+    onFocusIn(): void;
+    /** Handles focusout events for the menu bar. */
+    onFocusOut(event: FocusEvent): void;
+    /** Goes to and optionally focuses the specified menu item. */
+    goto(item: MenuItemPattern<V>, opts?: {
+        focusElement?: boolean;
+    }): void;
+    /** Focuses the next menu item. */
+    next(): void;
+    /** Focuses the previous menu item. */
+    prev(): void;
+    /** Closes the menubar and refocuses the root menu bar item. */
+    close(): void;
+}
+/** The menu trigger ui pattern class. */
+declare class MenuTriggerPattern<V> {
+    readonly inputs: MenuTriggerInputs<V>;
+    /** Whether the menu is expanded. */
+    expanded: WritableSignalLike<boolean>;
+    /** Whether the menu trigger has received focus. */
+    hasBeenFocused: WritableSignalLike<boolean>;
+    /** The role of the menu trigger. */
+    role: () => string;
+    /** Whether the menu trigger has a popup. */
+    hasPopup: () => boolean;
+    /** The menu associated with the trigger. */
+    menu: SignalLike<MenuPattern<V> | undefined>;
+    /** The tab index of the menu trigger. */
+    tabIndex: SignalLike<-1 | 0>;
+    /** Whether the menu trigger is disabled. */
+    disabled: () => boolean;
+    /** Handles keyboard events for the menu trigger. */
+    keydownManager: SignalLike<KeyboardEventManager<KeyboardEvent>>;
+    constructor(inputs: MenuTriggerInputs<V>);
+    /** Handles keyboard events for the menu trigger. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Handles click events for the menu trigger. */
+    onClick(): void;
+    /** Handles focusin events for the menu trigger. */
+    onFocusIn(): void;
+    /** Handles focusout events for the menu trigger. */
+    onFocusOut(event: FocusEvent): void;
+    /** Opens the menu. */
+    open(opts?: {
+        first?: boolean;
+        last?: boolean;
+    }): void;
+    /** Closes the menu. */
+    close(opts?: {
+        refocus?: boolean;
+    }): void;
+}
+/** The menu item ui pattern class. */
+declare class MenuItemPattern<V> implements ListItem<V> {
+    readonly inputs: MenuItemInputs<V>;
+    /** The value of the menu item. */
+    value: SignalLike<V>;
+    /** The unique ID of the menu item. */
+    id: SignalLike<string>;
+    /** Whether the menu item is disabled. */
+    disabled: () => boolean;
+    /** The search term for the menu item. */
+    searchTerm: SignalLike<string>;
+    /** The element of the menu item. */
+    element: SignalLike<HTMLElement | undefined>;
+    /** Whether the menu item is active. */
+    active: SignalLike<boolean>;
+    /** Whether the menu item has received focus. */
+    hasBeenFocused: WritableSignalLike<boolean>;
+    /** The tab index of the menu item. */
+    tabIndex: SignalLike<0 | -1>;
+    /** The position of the menu item in the menu. */
+    index: SignalLike<number>;
+    /** Whether the menu item is expanded. */
+    expanded: SignalLike<boolean | null>;
+    /** Whether the menu item is expanded. */
+    _expanded: WritableSignalLike<boolean>;
+    /** The ID of the menu that the menu item controls. */
+    controls: WritableSignalLike<string | undefined>;
+    /** The role of the menu item. */
+    role: () => string;
+    /** Whether the menu item has a popup. */
+    hasPopup: SignalLike<boolean>;
+    /** The submenu associated with the menu item. */
+    submenu: SignalLike<MenuPattern<V> | undefined>;
+    /** Whether the menu item is selectable. */
+    selectable: SignalLike<boolean>;
+    constructor(inputs: MenuItemInputs<V>);
+    /** Opens the submenu. */
+    open(opts?: {
+        first?: boolean;
+        last?: boolean;
+    }): void;
+    /** Closes the submenu. */
+    close(opts?: {
+        refocus?: boolean;
+    }): void;
+    /** Handles focusin events for the menu item. */
+    onFocusIn(): void;
+}
+
+export { MenuBarPattern, MenuItemPattern, MenuPattern, MenuTriggerPattern };
+export type { MenuBarInputs, MenuInputs, MenuItemInputs, MenuTriggerInputs };

package/types/_pointer-event-manager-chunk.d.ts

@@ -0,0 +1,34 @@
+import { EventManager, EventHandlerOptions, ModifierInputs, EventHandler } from './_keyboard-event-manager-chunk.js';
+
+/**
+ * The different mouse buttons that may appear on a pointer event.
+ */
+declare enum MouseButton {
+    Main = 0,
+    Auxiliary = 1,
+    Secondary = 2
+}
+/** An event manager that is specialized for handling pointer events. */
+declare class PointerEventManager<T extends PointerEvent> extends EventManager<T> {
+    options: EventHandlerOptions;
+    /**
+     * Configures this event manager to handle events with a specific modifer and mouse button
+     * combination.
+     */
+    on(button: MouseButton, modifiers: ModifierInputs, handler: EventHandler<T>): this;
+    /**
+     * Configures this event manager to handle events with a specific mouse button and no modifiers.
+     */
+    on(modifiers: ModifierInputs, handler: EventHandler<T>): this;
+    /**
+     * Configures this event manager to handle events with the main mouse button and no modifiers.
+     *
+     * @param handler The handler function
+     * @param options Options for whether to stop propagation or prevent default.
+     */
+    on(handler: EventHandler<T>): this;
+    private _normalizeInputs;
+    _isMatch(event: PointerEvent, button: MouseButton, modifiers: ModifierInputs): boolean;
+}
+
+export { PointerEventManager };