@hanifhan1f/vidstack 1.12.13

package/types/components/ui/buttons/fullscreen-button.d.ts

@@ -0,0 +1,28 @@
+import { Component } from 'maverick.js';
+import type { MediaFullscreenRequestTarget, MediaRequestEvents } from '../../../core/api/media-request-events';
+import { type ToggleButtonControllerProps } from './toggle-button-controller';
+export interface FullscreenButtonProps extends ToggleButtonControllerProps {
+    /**
+     * The target element on which to request fullscreen on. The target can be `media`
+     * (i.e., `<media-player>`) or `provider`. The `prefer-media` option will first see if the native
+     * fullscreen API is available, if not it'll try the media provider.
+     */
+    target: MediaFullscreenRequestTarget | undefined;
+}
+export interface FullscreenButtonEvents extends Pick<MediaRequestEvents, 'media-enter-fullscreen-request' | 'media-exit-fullscreen-request'> {
+}
+/**
+ * A button for toggling the fullscreen mode of the player.
+ *
+ * @attr data-active - Whether fullscreen mode is active.
+ * @attr data-supported - Whether fullscreen mode is supported.
+ * @docs {@link https://www.vidstack.io/docs/player/components/buttons/fullscreen-button}
+ * @see {@link https://www.vidstack.io/docs/player/api/fullscreen}
+ */
+export declare class FullscreenButton extends Component<FullscreenButtonProps, {}, FullscreenButtonEvents> {
+    #private;
+    static props: FullscreenButtonProps;
+    constructor();
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+}

package/types/components/ui/buttons/google-cast-button.d.ts

@@ -0,0 +1,23 @@
+import { Component } from 'maverick.js';
+import type { MediaRequestEvents } from '../../../core/api/media-request-events';
+import { type ToggleButtonControllerProps } from './toggle-button-controller';
+export interface GoogleCastButtonProps extends ToggleButtonControllerProps {
+}
+export interface GoogleCastButtonEvents extends Pick<MediaRequestEvents, 'media-google-cast-request'> {
+}
+/**
+ * A button for requesting remote playback via Google Cast.
+ *
+ * @attr data-active - Whether Google Cast is connected.
+ * @attr data-supported - Whether Google Cast is available.
+ * @attr data-state - Current connection state.
+ * @see {@link https://developers.google.com/cast/docs/overview}
+ * @docs {@link https://www.vidstack.io/docs/player/components/buttons/google-cast-button}
+ */
+export declare class GoogleCastButton extends Component<GoogleCastButtonProps, {}, GoogleCastButtonEvents> {
+    #private;
+    static props: GoogleCastButtonProps;
+    constructor();
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+}

package/types/components/ui/buttons/live-button.d.ts

@@ -0,0 +1,30 @@
+import { Component } from 'maverick.js';
+import type { MediaRequestEvents } from '../../../core/api/media-request-events';
+export interface LiveButtonProps {
+    /**
+     * Whether the button should be disabled (non-interactive). This will prevent seeking to the
+     * live edge when pressed.
+     */
+    disabled: boolean;
+}
+export interface LiveButtonEvents extends Pick<MediaRequestEvents, 'media-live-edge-request'> {
+}
+/**
+ * This component displays the current live status of the stream. This includes whether it's
+ * live, at the live edge, or not live. In addition, when this button is pressed it will skip
+ * ahead to the live edge.
+ *
+ * @attr data-edge - Playback is at the live edge.
+ * @attr data-hidden - Whether current media is _not_ live.
+ * @attr data-focus - Whether button is being keyboard focused.
+ * @attr data-hocus - Whether button is being keyboard focused or hovered over.
+ * @docs {@link https://www.vidstack.io/docs/player/components/buttons/live-button}
+ */
+export declare class LiveButton extends Component<LiveButtonProps, {}, LiveButtonEvents> {
+    #private;
+    static props: LiveButtonProps;
+    constructor();
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+    protected onConnect(el: HTMLElement): void;
+}

package/types/components/ui/buttons/mute-button.d.ts

@@ -0,0 +1,21 @@
+import { Component } from 'maverick.js';
+import type { MediaRequestEvents } from '../../../core/api/media-request-events';
+import { type ToggleButtonControllerProps } from './toggle-button-controller';
+export interface MuteButtonProps extends ToggleButtonControllerProps {
+}
+export interface MuteButtonEvents extends Pick<MediaRequestEvents, 'media-mute-request' | 'media-unmute-request'> {
+}
+/**
+ * A button for toggling the muted state of the player.
+ *
+ * @attr data-muted - Whether volume is muted (0).
+ * @attr data-state - Current volume setting (low/high/muted).
+ * @docs {@link https://www.vidstack.io/docs/player/components/buttons/mute-button}
+ */
+export declare class MuteButton extends Component<MuteButtonProps, {}, MuteButtonEvents> {
+    #private;
+    static props: MuteButtonProps;
+    constructor();
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+}

package/types/components/ui/buttons/pip-button.d.ts

@@ -0,0 +1,22 @@
+import { Component } from 'maverick.js';
+import type { MediaRequestEvents } from '../../../core/api/media-request-events';
+import { type ToggleButtonControllerProps } from './toggle-button-controller';
+export interface PIPButtonProps extends ToggleButtonControllerProps {
+}
+export interface PIPButtonEvents extends Pick<MediaRequestEvents, 'media-enter-pip-request' | 'media-exit-pip-request'> {
+}
+/**
+ * A button for toggling the picture-in-picture (PIP) mode of the player.
+ *
+ * @attr data-active - Whether picture-in-picture mode is active.
+ * @attr data-supported - Whether picture-in-picture mode is available.
+ * @docs {@link https://www.vidstack.io/docs/player/components/buttons/pip-button}
+ * @see {@link https://www.vidstack.io/docs/player/api/picture-in-picture}
+ */
+export declare class PIPButton extends Component<PIPButtonProps, {}, PIPButtonEvents> {
+    #private;
+    static props: PIPButtonProps;
+    constructor();
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+}

package/types/components/ui/buttons/play-button.d.ts

@@ -0,0 +1,21 @@
+import { Component } from 'maverick.js';
+import type { MediaRequestEvents } from '../../../core/api/media-request-events';
+import { type ToggleButtonControllerProps } from './toggle-button-controller';
+export interface PlayButtonProps extends ToggleButtonControllerProps {
+}
+export interface PlayButtonEvents extends Pick<MediaRequestEvents, 'media-play-request' | 'media-pause-request'> {
+}
+/**
+ * A button for toggling the playback state (play/pause) of the current media.
+ *
+ * @attr data-paused - Whether playback has stopped.
+ * @attr data-ended - Whether playback has ended.
+ * @docs {@link https://www.vidstack.io/docs/player/components/buttons/play-button}
+ */
+export declare class PlayButton extends Component<PlayButtonProps, {}, PlayButtonEvents> {
+    #private;
+    static props: PlayButtonProps;
+    constructor();
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+}

package/types/components/ui/buttons/seek-button.d.ts

@@ -0,0 +1,32 @@
+import { Component } from 'maverick.js';
+import type { MediaRequestEvents } from '../../../core/api/media-request-events';
+export interface SeekButtonProps {
+    /**
+     * Whether the button should be disabled (non-interactive).
+     */
+    disabled: boolean;
+    /**
+     * The amount to seek the media playback forwards (positive number) or backwards (negative number)
+     * when the seek button is pressed.
+     */
+    seconds: number;
+}
+export interface SeekButtonEvents extends Pick<MediaRequestEvents, 'media-seek-request'> {
+}
+/**
+ * A button for seeking the current media playback forwards or backwards by a specified amount.
+ *
+ * @attr data-seeking - Whether a seeking operation is in progress.
+ * @attr data-supported - Whether seeking operations are permitted.
+ * @attr data-focus - Whether button is being keyboard focused.
+ * @attr data-hocus - Whether button is being keyboard focused or hovered over.
+ * @docs {@link https://www.vidstack.io/docs/player/components/buttons/seek-button}
+ */
+export declare class SeekButton extends Component<SeekButtonProps, {}, SeekButtonEvents> {
+    #private;
+    static props: SeekButtonProps;
+    constructor();
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+    protected onConnect(el: HTMLElement): void;
+}

package/types/components/ui/buttons/toggle-button-controller.d.ts

@@ -0,0 +1,20 @@
+import { ViewController, type ReadSignal } from 'maverick.js';
+export interface ToggleButtonControllerProps {
+    /**
+     * Whether the button should be disabled (non-interactive).
+     */
+    disabled: boolean;
+}
+export interface ToggleButtonDelegate {
+    isPresssed: ReadSignal<boolean>;
+    keyShortcut?: string;
+    onPress?(event: Event): void;
+}
+export declare class ToggleButtonController extends ViewController<ToggleButtonControllerProps> {
+    #private;
+    static props: ToggleButtonControllerProps;
+    constructor(delegate: ToggleButtonDelegate);
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+    protected onConnect(el: HTMLElement): void;
+}

package/types/components/ui/buttons/toggle-button.d.ts

@@ -0,0 +1,29 @@
+import { Component } from 'maverick.js';
+export interface ToggleButtonProps {
+    /**
+     * Whether it should start in the on (pressed) state.
+     */
+    defaultPressed: boolean;
+    /**
+     * Whether the button should be disabled (non-interactive).
+     */
+    disabled: boolean;
+}
+/**
+ * A toggle button is a two-state button that can be either off (not pressed) or on (pressed).
+ *
+ * @attr data-pressed - Whether the toggle is in an "on" state (pressed).
+ * @attr aria-pressed - Same as `data-pressed` but `"true"` or `"false"`.
+ * @attr data-focus - Whether button is being keyboard focused.
+ * @attr data-hocus - Whether button is being keyboard focused or hovered over.
+ * @docs {@link https://www.vidstack.io/docs/player/components/buttons/toggle-button}
+ */
+export declare class ToggleButton<Props extends ToggleButtonProps = ToggleButtonProps> extends Component<Props> {
+    #private;
+    static props: ToggleButtonProps;
+    /**
+     * Whether the toggle is currently in a `pressed` state.
+     */
+    get pressed(): boolean;
+    constructor();
+}

package/types/components/ui/captions/captions-renderer.d.ts

@@ -0,0 +1,12 @@
+import type { CaptionsRenderer } from 'media-captions';
+import type { TextRenderer } from '../../../core/tracks/text/render/text-renderer';
+import type { TextTrack } from '../../../core/tracks/text/text-track';
+export declare class CaptionsTextRenderer implements TextRenderer {
+    #private;
+    readonly priority = 10;
+    constructor(renderer: CaptionsRenderer);
+    attach(): void;
+    canRender(): boolean;
+    detach(): void;
+    changeTrack(track: TextTrack | null): void;
+}

package/types/components/ui/captions/captions.d.ts

@@ -0,0 +1,22 @@
+import { Component } from 'maverick.js';
+export interface CaptionsProps {
+    textDir: 'ltr' | 'rtl';
+    /**
+     * The text to be displayed when an example caption is being shown.
+     */
+    exampleText: string;
+}
+/**
+ * Renders and displays captions/subtitles. This will be an overlay for video and a simple
+ * captions box for audio.
+ *
+ * @docs {@link https://www.vidstack.io/docs/player/components/display/captions}
+ */
+export declare class Captions extends Component<CaptionsProps> {
+    #private;
+    static props: CaptionsProps;
+    static lib: import("maverick.js").WriteSignal<typeof import("media-captions") | null>;
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+    protected onConnect(el: HTMLElement): void;
+}

package/types/components/ui/controls-group.d.ts

@@ -0,0 +1,9 @@
+import { Component } from 'maverick.js';
+/**
+ * This component creates a container for media controls.
+ *
+ * @docs {@link https://www.vidstack.io/docs/player/components/media/controls#group}
+ */
+export declare class ControlsGroup extends Component {
+    protected onAttach(el: HTMLElement): void;
+}

package/types/components/ui/controls.d.ts

@@ -0,0 +1,38 @@
+import { Component } from 'maverick.js';
+import { DOMEvent } from 'maverick.js/std';
+/**
+ * This component creates a container for control groups.
+ *
+ * @attr data-visible - Whether controls should be visible.
+ * @attr data-pip - Whether picture-in-picture mode is active.
+ * @attr data-fullscreen - Whether fullscreen mode is active.
+ * @docs {@link https://www.vidstack.io/docs/player/components/media/controls}
+ */
+export declare class Controls extends Component<ControlsProps, {}, ControlsEvents> {
+    #private;
+    static props: ControlsProps;
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+}
+export interface ControlsProps {
+    /**
+     * The default amount of delay in milliseconds while media playback is progressing without user
+     * activity to hide the controls.
+     */
+    hideDelay: number;
+    /**
+     * Whether controls visibility should be toggled when the mouse enters and leaves the player
+     * container.
+     */
+    hideOnMouseLeave: boolean;
+}
+export interface ControlsEvents {
+    change: ControlsChangeEvent;
+}
+/**
+ * Fired when the active state of the controls change.
+ *
+ * @detail isVisible
+ */
+export interface ControlsChangeEvent extends DOMEvent<boolean> {
+}

package/types/components/ui/gesture.d.ts

@@ -0,0 +1,64 @@
+import { Component } from 'maverick.js';
+import { DOMEvent } from 'maverick.js/std';
+/**
+ * This component enables actions to be performed on the media based on user gestures.
+ *
+ * @docs {@link https://www.vidstack.io/docs/player/components/media/gesture}
+ */
+export declare class Gesture extends Component<GestureProps, {}, GestureEvents> {
+    #private;
+    static props: GestureProps;
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+    protected onConnect(el: HTMLElement): void;
+}
+export interface GestureProps {
+    /**
+     * Whether this gesture should not be triggered.
+     */
+    disabled: boolean;
+    /**
+     * The DOM event type that will trigger this gesture. It can be any valid DOM event type. Any
+     * event can be prefixed with `dbl` to ensure it occurs twice in succession (max 200ms gap).
+     *
+     * @example 'pointerup'
+     * @example 'dblpointerup'
+     * @example 'mouseleave'
+     */
+    event: GestureEventType | undefined;
+    /**
+     * An action describes the type of media request event that will be dispatched, which will
+     * ultimately perform some operation on the player.
+     *
+     * @example 'play'
+     * @example 'seek:30'
+     * @example 'seek:-30'
+     * @example 'toggle:paused'
+     */
+    action: GestureAction | undefined;
+}
+export type GestureEventType = keyof HTMLElementEventMap | `dbl${keyof HTMLElementEventMap}`;
+export type GestureAction = 'play' | 'pause' | `seek:${number}` | `toggle:${'paused' | 'muted' | 'fullscreen' | 'controls'}`;
+export interface GestureEvents {
+    'will-trigger': GestureWillTriggerEvent;
+    trigger: GestureTriggerEvent;
+}
+export interface GestureEvent<Detail = unknown> extends DOMEvent<Detail> {
+    target: Gesture;
+}
+/**
+ * This event will fire before the gesture action is triggered. Calling `event.preventDefault()`
+ * will stop the action from being triggered.
+ *
+ * @detail action
+ * @cancelable
+ */
+export interface GestureWillTriggerEvent extends GestureEvent<GestureAction> {
+}
+/**
+ * This event will fire after the gesture action has been triggered.
+ *
+ * @detail action
+ */
+export interface GestureTriggerEvent extends GestureEvent<GestureAction> {
+}

package/types/components/ui/menu/menu-button.d.ts

@@ -0,0 +1,37 @@
+import { Component } from 'maverick.js';
+import { DOMEvent } from 'maverick.js/std';
+/**
+ * A button that controls the opening and closing of a menu component. The button will become a
+ * menuitem when used inside a submenu.
+ *
+ * @attr data-root - Whether this is the root menu button.
+ * @attr data-submenu - Whether menu button is part of a submenu.
+ * @attr data-open - Whether menu is currently open.
+ * @attr data-focus - Whether button is being keyboard focused.
+ * @attr data-hocus - Whether button is being keyboard focused or hovered over.
+ * @docs {@link https://www.vidstack.io/docs/player/components/menu/menu}
+ */
+export declare class MenuButton extends Component<MenuButtonProps, {}, MenuButtonEvents> {
+    #private;
+    static props: MenuButtonProps;
+    get expanded(): boolean;
+    constructor();
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+    protected onConnect(el: HTMLElement): void;
+}
+export interface MenuButtonProps {
+    /**
+     * Whether the button should be disabled (non-interactive).
+     */
+    disabled: boolean;
+}
+export interface MenuButtonEvents {
+    select: MenuButtonSelectEvent;
+}
+/**
+ * Fired when the button is pressed via mouse, touch, or keyboard.
+ */
+export interface MenuButtonSelectEvent extends DOMEvent<void> {
+    target: MenuButton;
+}

package/types/components/ui/menu/menu-context.d.ts

@@ -0,0 +1,23 @@
+import { type ReadSignal, type WriteSignal } from 'maverick.js';
+import type { Menu } from './menu';
+import type { MenuButton } from './menu-button';
+import type { MenuItems } from './menu-items';
+export interface MenuContext {
+    readonly submenu: boolean;
+    readonly expanded: ReadSignal<boolean>;
+    readonly hint: WriteSignal<string>;
+    readonly button: ReadSignal<HTMLElement | null>;
+    readonly content: ReadSignal<HTMLElement | null>;
+    attachMenuButton(button: MenuButton): void;
+    attachMenuItems(menuItems: MenuItems): void;
+    attachObserver(observer: MenuObserver): void;
+    disable(disable: boolean): void;
+    disableMenuButton(disable: boolean): void;
+    addSubmenu(menu: Menu): void;
+    onTransitionEvent(callback: (event: TransitionEvent) => void): void;
+}
+export interface MenuObserver {
+    onOpen?(trigger?: Event): void;
+    onClose?(trigger?: Event): void;
+}
+export declare const menuContext: import("maverick.js").Context<MenuContext>;

package/types/components/ui/menu/menu-focus-controller.d.ts

@@ -0,0 +1,14 @@
+export interface MenuFocusControllerDelegate {
+    closeMenu(trigger?: Event): void;
+}
+export declare class MenuFocusController {
+    #private;
+    get items(): HTMLElement[];
+    constructor(delegate: MenuFocusControllerDelegate);
+    attachMenu(el: HTMLElement): void;
+    listen(): void;
+    update(): void;
+    scroll(index?: number): void;
+    focusActive(scroll?: boolean): void;
+}
+export declare function getMenuController(el: HTMLElement): HTMLElement | null;

package/types/components/ui/menu/menu-item.d.ts

@@ -0,0 +1,9 @@
+import { MenuButton } from './menu-button';
+/**
+ * Represents a specific option or action, typically displayed as a text label or icon, which
+ * users can select to access or perform a particular function or view related content.
+ *
+ * @docs {@link https://www.vidstack.io/docs/player/components/menu/menu}
+ */
+export declare class MenuItem extends MenuButton {
+}

package/types/components/ui/menu/menu-items.d.ts

@@ -0,0 +1,44 @@
+import { Component } from 'maverick.js';
+/**
+ * Menu items can be used to display settings or arbitrary content in a floating panel.
+ *
+ * @attr data-root - Whether this is the root menu items.
+ * @attr data-submenu - Whether menu items are part of a submenu.
+ * @attr data-open - Whether menu items are currently visible.
+ * @attr data-keyboard - Whether the menu is opened via keyboard.
+ * @attr data-placement - The placement prop setting.
+ * @attr data-focus - Whether item are being keyboard focused.
+ * @attr data-hocus - Whether items are being keyboard focused or hovered over.
+ * @attr data-transition - Whether the menu is resizing.
+ * @docs {@link https://www.vidstack.io/docs/player/components/menu/menu}
+ */
+export declare class MenuItems extends Component<MenuItemsProps> {
+    #private;
+    static props: MenuItemsProps;
+    constructor();
+    protected onAttach(el: HTMLElement): void;
+    protected onConnect(el: HTMLElement): void;
+}
+export type MenuPlacement = MenuPlacementSide | `${MenuPlacementSide} ${MenuPlacementAlign}`;
+export type MenuPlacementSide = 'top' | 'right' | 'bottom' | 'left';
+export type MenuPlacementAlign = 'start' | 'center' | 'end';
+export interface MenuItemsProps {
+    /**
+     * A space-separated list which specifies the side and alignment of the menu relative
+     * to the menu button.
+     *
+     * @example `top center`
+     * @example `bottom end`
+     */
+    placement: MenuPlacement | null;
+    /**
+     * The distance in pixels between the menu items and the menu button. You can also set
+     * the CSS variable `--media-menu-y-offset` to adjust this offset.
+     */
+    offset: number;
+    /**
+     * The offset in pixels from the start/center/end aligned position. You can also set
+     * the CSS variable `--media-menu-x-offset` to adjust this offset.
+     */
+    alignOffset: number;
+}

package/types/components/ui/menu/menu-portal.d.ts

@@ -0,0 +1,31 @@
+import { Component } from 'maverick.js';
+/**
+ * Portals menu items into the document body.
+ *
+ * @attr data-portal - Whether portal is active (determined by `disabled` prop).
+ * @docs {@link https://www.vidstack.io/docs/player/components/menu#portal}
+ */
+export declare class MenuPortal extends Component<MenuPortalProps> {
+    #private;
+    static props: MenuPortalProps;
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+    protected onConnect(el: HTMLElement): void;
+    protected onDestroy(): void;
+}
+export interface MenuPortalProps {
+    /**
+     * Specifies a DOM element or query selector for the container that the menu should be portalled
+     * inside. Defaults to `document.body` when set to `null`.
+     */
+    container: string | HTMLElement | null;
+    /**
+     * Whether the portal should be disabled. The value can be the string "fullscreen" to disable
+     * portals while media is fullscreen. This is to ensure the menu remains visible.
+     */
+    disabled: boolean | 'fullscreen';
+}
+export interface MenuPortalContext {
+    attach(element: HTMLElement | null): void;
+}
+export declare const menuPortalContext: import("maverick.js").Context<MenuPortalContext | null>;

package/types/components/ui/menu/menu.d.ts

@@ -0,0 +1,66 @@
+import { Component } from 'maverick.js';
+import { DOMEvent } from 'maverick.js/std';
+import type { MediaRequestEvents } from '../../../core/api/media-request-events';
+/**
+ * Root menu container used to hold and manage a menu button and menu items. This component is
+ * used to display options in a floating panel. They can be nested to create submenus.
+ *
+ * @attr data-root - Whether this is the root menu items.
+ * @attr data-submenu - Whether menu is a submenu.
+ * @attr data-open - Whether menu is open.
+ * @attr data-keyboard - Whether the menu is opened via keyboard.
+ * @attr data-disabled - Whether menu is disabled.
+ * @docs {@link https://www.vidstack.io/docs/player/components/menu/menu}
+ */
+export declare class Menu extends Component<MenuProps, {}, MenuEvents> {
+    #private;
+    static props: MenuProps;
+    /**
+     * The menu trigger element.
+     */
+    get triggerElement(): HTMLElement | null;
+    /**
+     * The menu items element.
+     */
+    get contentElement(): HTMLElement | null;
+    /**
+     * Whether this menu is the child of another menu that contains it.
+     */
+    get isSubmenu(): boolean;
+    constructor();
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+    protected onConnect(el: HTMLElement): void;
+    protected onDestroy(): void;
+    /**
+     * Open this menu. The first menu item will be focused if a `KeyboardEvent` trigger is provided
+     */
+    open(trigger?: Event): void;
+    /**
+     * Close this menu. The menu button that controls this menu will be focused if a `KeyboardEvent`
+     * trigger is provided
+     */
+    close(trigger?: Event): void;
+}
+export interface MenuProps {
+    /**
+     * The amount of time in milliseconds to wait before showing the menu.
+     */
+    showDelay: number;
+}
+export interface MenuEvents extends Pick<MediaRequestEvents, 'media-pause-controls-request' | 'media-resume-controls-request'> {
+    open: MenuOpenEvent;
+    close: MenuCloseEvent;
+}
+/**
+ * Fired when the menu is opened.
+ */
+export interface MenuOpenEvent extends DOMEvent<void> {
+    target: Menu;
+}
+/**
+ * Fired when the menu is closed.
+ */
+export interface MenuCloseEvent extends DOMEvent<void> {
+    target: Menu;
+}

package/types/components/ui/menu/radio/radio-controller.d.ts

@@ -0,0 +1,14 @@
+import { type ReadSignal } from 'maverick.js';
+export interface RadioController {
+    value: ReadSignal<string>;
+    check(checked: boolean, trigger?: Event): any;
+    onCheck: RadioChangeCallback | null;
+}
+export interface RadioChangeCallback {
+    (value: string, trigger?: Event): void;
+}
+export interface RadioGroupContext {
+    add(radio: RadioController): void;
+    remove(radio: RadioController): void;
+}
+export declare const radioControllerContext: import("maverick.js").Context<RadioGroupContext>;

package/types/components/ui/menu/radio/radio-group-controller.d.ts

@@ -0,0 +1,11 @@
+import { ViewController } from 'maverick.js';
+export declare class RadioGroupController extends ViewController {
+    #private;
+    onValueChange?: (newValue: string, trigger?: Event) => void;
+    get values(): string[];
+    get value(): string;
+    set value(value: string);
+    protected onSetup(): void;
+    protected onAttach(el: HTMLElement): void;
+    protected onDestroy(): void;
+}