@prosekit/web 0.3.19 → 0.4.1

package/dist/_tsup-dts-rollup.d.ts

@@ -1,45 +1,71 @@
-import { BaseElement } from '@aria-ui/core';
+import { AutoUpdateOptions } from '@floating-ui/dom';
+import { BaseElementConstructor } from '@aria-ui/core';
 import { ConnectableElement } from '@aria-ui/core';
 import { Context } from '@aria-ui/core';
 import { config as default_alias_1 } from '@prosekit/dev/config-vitest';
-import { defaultPopoverContentProps } from '@aria-ui/popover';
-import { defaultPopoverRootProps } from '@aria-ui/popover';
-import { defaultPopoverTriggerProps } from '@aria-ui/popover';
-import { defaultTooltipRootProps } from '@aria-ui/tooltip';
-import { defaultTooltipTriggerProps } from '@aria-ui/tooltip';
 import type { defineTableCommands } from '@prosekit/extensions/table';
 import { Editor } from '@prosekit/core';
 import type { EditorView } from '@prosekit/pm/view';
-import type { EmptyObject } from '@aria-ui/core';
+import { ElementContext } from '@floating-ui/dom';
+import { EventDeclarations } from '@aria-ui/core';
 import type { Extension } from '@prosekit/core';
 import { FocusChangeHandler } from '@prosekit/core';
 import { ItemFilter } from '@aria-ui/collection';
 import { Keymap } from '@prosekit/core';
+import { ListboxEvents } from '@aria-ui/listbox';
+import { ListboxItemEvents } from '@aria-ui/listbox';
 import { ListboxProps } from '@aria-ui/listbox';
-import { MenuContentProps } from '@aria-ui/menu';
+import { MenuContentEvents } from '@aria-ui/menu/elements';
+import { MenuContentProps } from '@aria-ui/menu/elements';
+import { MenuItemEvents } from '@aria-ui/menu';
 import { MenuItemProps } from '@aria-ui/menu';
 import { Options } from 'tsup';
-import { OverlayPositionerProps } from '@aria-ui/overlay';
-import type { Placement } from '@floating-ui/dom';
+import { OverlayPositionerEvents } from '@aria-ui/overlay/elements';
+import { OverlayPositionerEvents as OverlayPositionerEvents_2 } from '@aria-ui/overlay';
+import { OverlayPositionerProps } from '@aria-ui/overlay/elements';
+import { OverlayPositionerProps as OverlayPositionerProps_2 } from '@aria-ui/overlay';
+import { Placement } from '@floating-ui/dom';
 import { PlainExtension } from '@prosekit/core';
-import { PopoverContentProps } from '@aria-ui/popover';
-import { PopoverRootProps } from '@aria-ui/popover';
-import { PopoverTriggerProps } from '@aria-ui/popover';
+import { popoverContentEvents } from '@aria-ui/popover/elements';
+import type { PopoverContentEvents as PopoverContentEvents_2 } from '@aria-ui/popover/elements';
+import { popoverContentProps } from '@aria-ui/popover/elements';
+import type { PopoverContentProps as PopoverContentProps_2 } from '@aria-ui/popover/elements';
+import { popoverRootEvents } from '@aria-ui/popover/elements';
+import type { PopoverRootEvents as PopoverRootEvents_2 } from '@aria-ui/popover/elements';
+import { popoverRootProps } from '@aria-ui/popover/elements';
+import type { PopoverRootProps as PopoverRootProps_2 } from '@aria-ui/popover/elements';
+import { popoverTriggerEvents } from '@aria-ui/popover/elements';
+import type { PopoverTriggerEvents as PopoverTriggerEvents_2 } from '@aria-ui/popover/elements';
+import { popoverTriggerProps } from '@aria-ui/popover/elements';
+import type { PopoverTriggerProps as PopoverTriggerProps_2 } from '@aria-ui/popover/elements';
+import { PropDeclaration } from '@aria-ui/core';
+import { PropDeclarations } from '@aria-ui/core';
 import type { ProseMirrorNode } from '@prosekit/pm/model';
 import { ReadonlySignal } from '@aria-ui/core';
 import type { ReferenceElement } from '@floating-ui/dom';
+import { RootBoundary } from '@floating-ui/dom';
+import { SetupOptions } from '@aria-ui/core';
 import { SignalState } from '@aria-ui/core';
-import { TooltipContentProps } from '@aria-ui/tooltip';
-import { TooltipRootProps } from '@aria-ui/tooltip';
-import { TooltipTriggerProps } from '@aria-ui/tooltip';
+import { tooltipContentEvents } from '@aria-ui/tooltip';
+import { TooltipContentEvents as TooltipContentEvents_2 } from '@aria-ui/tooltip';
+import { TooltipContentProps as TooltipContentProps_2 } from '@aria-ui/tooltip';
+import { tooltipRootEvents } from '@aria-ui/tooltip/elements';
+import type { TooltipRootEvents as TooltipRootEvents_2 } from '@aria-ui/tooltip/elements';
+import { tooltipRootProps } from '@aria-ui/tooltip/elements';
+import type { TooltipRootProps as TooltipRootProps_2 } from '@aria-ui/tooltip/elements';
+import { tooltipTriggerEvents } from '@aria-ui/tooltip/elements';
+import type { TooltipTriggerEvents as TooltipTriggerEvents_2 } from '@aria-ui/tooltip/elements';
+import { tooltipTriggerProps } from '@aria-ui/tooltip/elements';
+import type { TooltipTriggerProps as TooltipTriggerProps_2 } from '@aria-ui/tooltip/elements';
 import { Union } from '@prosekit/core';
 import { UpdateHandler } from '@prosekit/core';
-import { usePopoverContent } from '@aria-ui/popover';
-import { usePopoverRoot } from '@aria-ui/popover';
-import { usePopoverTrigger } from '@aria-ui/popover';
-import { useTooltipContent } from '@aria-ui/tooltip';
-import { useTooltipRoot } from '@aria-ui/tooltip';
-import { useTooltipTrigger } from '@aria-ui/tooltip';
+import { useListboxEmpty } from '@aria-ui/listbox/elements';
+import { usePopoverContent } from '@aria-ui/popover/elements';
+import { usePopoverRoot } from '@aria-ui/popover/elements';
+import { usePopoverTrigger } from '@aria-ui/popover/elements';
+import { useTooltipContent } from '@aria-ui/tooltip/elements';
+import { useTooltipRoot } from '@aria-ui/tooltip/elements';
+import { useTooltipTrigger } from '@aria-ui/tooltip/elements';
 import type { VirtualElement } from '@floating-ui/dom';
 
 declare class AutocompleteEmptyElement extends AutocompleteEmptyElement_base {
@@ -47,25 +73,46 @@ declare class AutocompleteEmptyElement extends AutocompleteEmptyElement_base {
 export { AutocompleteEmptyElement }
 export { AutocompleteEmptyElement as AutocompleteEmptyElement_alias_1 }
 
-declare const AutocompleteEmptyElement_base: {
-    new (): BaseElement & AutocompleteEmptyProps;
-    prototype: HTMLElement;
-};
+declare const AutocompleteEmptyElement_base: BaseElementConstructor<AutocompleteEmptyProps>;
+
+/** @internal */
+declare interface AutocompleteEmptyEvents {
+}
+export { AutocompleteEmptyEvents }
+export { AutocompleteEmptyEvents as AutocompleteEmptyEvents_alias_1 }
+
+/** @internal */
+declare const autocompleteEmptyEvents: EventDeclarations<AutocompleteEmptyEvents>;
+export { autocompleteEmptyEvents }
+export { autocompleteEmptyEvents as autocompleteEmptyEvents_alias_1 }
 
-declare interface AutocompleteEmptyProps extends EmptyObject {
+/** @internal */
+declare interface AutocompleteEmptyProps {
 }
 export { AutocompleteEmptyProps }
 export { AutocompleteEmptyProps as AutocompleteEmptyProps_alias_1 }
 
+/** @internal */
+declare const autocompleteEmptyProps: PropDeclarations<AutocompleteEmptyProps>;
+export { autocompleteEmptyProps }
+export { autocompleteEmptyProps as autocompleteEmptyProps_alias_1 }
+
 declare class AutocompleteItemElement extends AutocompleteItemElement_base {
 }
 export { AutocompleteItemElement }
 export { AutocompleteItemElement as AutocompleteItemElement_alias_1 }
 
-declare const AutocompleteItemElement_base: {
-    new (): BaseElement & AutocompleteItemProps;
-    prototype: HTMLElement;
-};
+declare const AutocompleteItemElement_base: BaseElementConstructor<AutocompleteItemProps>;
+
+declare interface AutocompleteItemEvents extends ListboxItemEvents {
+}
+export { AutocompleteItemEvents }
+export { AutocompleteItemEvents as AutocompleteItemEvents_alias_1 }
+
+/** @internal */
+declare const autocompleteItemEvents: EventDeclarations<AutocompleteItemEvents>;
+export { autocompleteItemEvents }
+export { autocompleteItemEvents as autocompleteItemEvents_alias_1 }
 
 declare interface AutocompleteItemProps {
     /**
@@ -76,47 +123,75 @@ declare interface AutocompleteItemProps {
      * @default ""
      */
     value: string;
-    /**
-     * The function to call when the item is selected.
-     *
-     * @default null
-     */
-    onSelect: VoidFunction | null;
 }
 export { AutocompleteItemProps }
 export { AutocompleteItemProps as AutocompleteItemProps_alias_1 }
 
+/** @internal */
+declare const autocompleteItemProps: PropDeclarations<AutocompleteItemProps>;
+export { autocompleteItemProps }
+export { autocompleteItemProps as autocompleteItemProps_alias_1 }
+
 declare class AutocompleteListElement extends AutocompleteListElement_base {
 }
 export { AutocompleteListElement }
 export { AutocompleteListElement as AutocompleteListElement_alias_1 }
 
-declare const AutocompleteListElement_base: {
-    new (): BaseElement & AutocompleteListProps;
-    prototype: HTMLElement;
-};
+declare const AutocompleteListElement_base: BaseElementConstructor<AutocompleteListProps>;
+
+declare interface AutocompleteListEvents extends ListboxEvents {
+}
+export { AutocompleteListEvents }
+export { AutocompleteListEvents as AutocompleteListEvents_alias_1 }
+
+declare const autocompleteListEvents: EventDeclarations<ListboxEvents>;
+export { autocompleteListEvents }
+export { autocompleteListEvents as autocompleteListEvents_alias_1 }
 
 declare interface AutocompleteListProps extends Pick<ListboxProps, 'filter'> {
+    /**
+     * The ProseKit editor instance.
+     *
+     * @default null
+     * @hidden
+     */
     editor: Editor | null;
 }
 export { AutocompleteListProps }
 export { AutocompleteListProps as AutocompleteListProps_alias_1 }
 
+declare const autocompleteListProps: {
+    filter: PropDeclaration<ItemFilter | null>;
+    editor: {
+        default: null;
+    };
+};
+export { autocompleteListProps }
+export { autocompleteListProps as autocompleteListProps_alias_1 }
+
 declare class AutocompletePopoverElement extends AutocompletePopoverElement_base {
 }
 export { AutocompletePopoverElement }
 export { AutocompletePopoverElement as AutocompletePopoverElement_alias_1 }
 
-declare const AutocompletePopoverElement_base: {
-    new (): BaseElement & AutocompletePopoverProps;
-    prototype: HTMLElement;
-};
+declare const AutocompletePopoverElement_base: BaseElementConstructor<AutocompletePopoverProps>;
+
+declare interface AutocompletePopoverEvents extends OverlayPositionerEvents {
+}
+export { AutocompletePopoverEvents }
+export { AutocompletePopoverEvents as AutocompletePopoverEvents_alias_1 }
+
+/** @internal */
+declare const autocompletePopoverEvents: EventDeclarations<AutocompletePopoverEvents>;
+export { autocompletePopoverEvents }
+export { autocompletePopoverEvents as autocompletePopoverEvents_alias_1 }
 
 declare interface AutocompletePopoverProps extends OverlayPositionerProps {
     /**
      * The ProseKit editor instance.
      *
      * @default null
+     * @hidden
      */
     editor: Editor | null;
     /**
@@ -169,112 +244,151 @@ declare interface AutocompletePopoverProps extends OverlayPositionerProps {
 export { AutocompletePopoverProps }
 export { AutocompletePopoverProps as AutocompletePopoverProps_alias_1 }
 
-declare class BlockDragHandleElement extends BlockDragHandleElement_base {
-}
-export { BlockDragHandleElement }
-export { BlockDragHandleElement as BlockDragHandleElement_alias_1 }
-
-declare const BlockDragHandleElement_base: {
-    new (): BaseElement & BlockDragHandleProps;
-    prototype: HTMLElement;
+/** @internal */
+declare const autocompletePopoverProps: {
+    readonly editor: {
+        readonly default: null;
+    };
+    readonly regex: {
+        readonly default: null;
+    };
+    readonly onQueryChange: {
+        readonly default: null;
+    };
+    readonly onOpenChange: {
+        readonly default: null;
+    };
+    readonly placement: {
+        readonly default: "bottom-start";
+    };
+    readonly offset: {
+        readonly default: 4;
+    };
+    readonly inline: {
+        readonly default: true;
+    };
+    readonly hoist: {
+        readonly default: true;
+    };
+    readonly fitViewport: {
+        readonly default: true;
+    };
+    readonly boundary: {
+        readonly default: HTMLBodyElement | "clippingAncestors";
+    };
+    readonly overflowPadding: {
+        readonly default: 8;
+    };
+    readonly strategy: PropDeclaration<"fixed" | "absolute">;
+    readonly autoUpdate: PropDeclaration<boolean | AutoUpdateOptions>;
+    readonly transform: PropDeclaration<boolean>;
+    readonly flip: PropDeclaration<boolean | Placement[]>;
+    readonly shift: PropDeclaration<boolean>;
+    readonly overlap: PropDeclaration<boolean>;
+    readonly sameWidth: PropDeclaration<boolean>;
+    readonly sameHeight: PropDeclaration<boolean>;
+    readonly hide: PropDeclaration<boolean>;
+    readonly rootBoundary: PropDeclaration<RootBoundary>;
+    readonly elementContext: PropDeclaration<ElementContext>;
+    readonly altBoundary: PropDeclaration<boolean>;
 };
-
-/**
- * @deprecated Use `BlockHandleDraggableProps` instead.
- */
-declare interface BlockDragHandleProps {
-    /**
-     * The ProseKit editor instance.
-     *
-     * @default null
-     */
-    editor: Editor | null;
-}
-export { BlockDragHandleProps }
-export { BlockDragHandleProps as BlockDragHandleProps_alias_1 }
+export { autocompletePopoverProps }
+export { autocompletePopoverProps as autocompletePopoverProps_alias_1 }
 
 declare class BlockHandleAddElement extends BlockHandleAddElement_base {
 }
 export { BlockHandleAddElement }
 export { BlockHandleAddElement as BlockHandleAddElement_alias_1 }
 
-declare const BlockHandleAddElement_base: {
-    new (): BaseElement & BlockHandleAddProps;
-    prototype: HTMLElement;
-};
+declare const BlockHandleAddElement_base: BaseElementConstructor<BlockHandleAddProps>;
+
+/** @internal */
+declare interface BlockHandleAddEvents {
+}
+export { BlockHandleAddEvents }
+export { BlockHandleAddEvents as BlockHandleAddEvents_alias_1 }
+
+/** @internal */
+declare const blockHandleAddEvents: EventDeclarations<BlockHandleAddEvents>;
+export { blockHandleAddEvents }
+export { blockHandleAddEvents as blockHandleAddEvents_alias_1 }
 
 declare interface BlockHandleAddProps {
     /**
      * The ProseKit editor instance.
      *
      * @default null
+     * @hidden
      */
     editor: Editor | null;
 }
 export { BlockHandleAddProps }
 export { BlockHandleAddProps as BlockHandleAddProps_alias_1 }
 
+/** @internal */
+declare const blockHandleAddProps: PropDeclarations<BlockHandleAddProps>;
+export { blockHandleAddProps }
+export { blockHandleAddProps as blockHandleAddProps_alias_1 }
+
 declare class BlockHandleDraggableElement extends BlockHandleDraggableElement_base {
 }
 export { BlockHandleDraggableElement }
 export { BlockHandleDraggableElement as BlockHandleDraggableElement_alias_1 }
 
-declare const BlockHandleDraggableElement_base: {
-    new (): BaseElement & BlockHandleDraggableProps;
-    prototype: HTMLElement;
-};
+declare const BlockHandleDraggableElement_base: BaseElementConstructor<BlockHandleDraggableProps>;
+
+/** @internal */
+declare interface BlockHandleDraggableEvents {
+}
+export { BlockHandleDraggableEvents }
+export { BlockHandleDraggableEvents as BlockHandleDraggableEvents_alias_1 }
+
+/** @internal */
+declare const blockHandleDraggableEvents: EventDeclarations<BlockHandleDraggableEvents>;
+export { blockHandleDraggableEvents }
+export { blockHandleDraggableEvents as blockHandleDraggableEvents_alias_1 }
 
 declare interface BlockHandleDraggableProps {
     /**
      * The ProseKit editor instance.
      *
      * @default null
+     * @hidden
      */
     editor: Editor | null;
 }
 export { BlockHandleDraggableProps }
 export { BlockHandleDraggableProps as BlockHandleDraggableProps_alias_1 }
 
+/** @internal */
+declare const blockHandleDraggableProps: PropDeclarations<BlockHandleDraggableProps>;
+export { blockHandleDraggableProps }
+export { blockHandleDraggableProps as blockHandleDraggableProps_alias_1 }
+
 declare class BlockHandlePopoverElement extends BlockHandlePopoverElement_base {
 }
 export { BlockHandlePopoverElement }
 export { BlockHandlePopoverElement as BlockHandlePopoverElement_alias_1 }
 
-declare const BlockHandlePopoverElement_base: {
-    new (): BaseElement & BlockHandlePopoverProps;
-    prototype: HTMLElement;
-};
-
-declare interface BlockHandlePopoverProps extends BlockPopoverProps {
-}
-export { BlockHandlePopoverProps }
-export { BlockHandlePopoverProps as BlockHandlePopoverProps_alias_1 }
-
-/**
- * @internal
- */
-export declare type BlockPopoverContext = HoverState | null;
-
-/**
- * @internal
- */
-export declare const blockPopoverContext: Context<BlockPopoverContext>;
+declare const BlockHandlePopoverElement_base: BaseElementConstructor<BlockHandlePopoverProps>;
 
-declare class BlockPopoverElement extends BlockPopoverElement_base {
+/** @internal */
+declare interface BlockHandlePopoverEvents {
 }
-export { BlockPopoverElement }
-export { BlockPopoverElement as BlockPopoverElement_alias_1 }
+export { BlockHandlePopoverEvents }
+export { BlockHandlePopoverEvents as BlockHandlePopoverEvents_alias_1 }
 
-declare const BlockPopoverElement_base: {
-    new (): BaseElement & BlockPopoverProps;
-    prototype: HTMLElement;
-};
+/** @internal */
+declare const blockHandlePopoverEvents: EventDeclarations<BlockHandlePopoverEvents>;
+export { blockHandlePopoverEvents }
+export { blockHandlePopoverEvents as blockHandlePopoverEvents_alias_1 }
 
-declare interface BlockPopoverProps extends Omit<OverlayPositionerProps, 'placement' | 'offset'> {
+declare interface BlockHandlePopoverProps extends Omit<OverlayPositionerProps, 'placement' | 'offset'> {
     /**
      * The ProseKit editor instance.
      *
      * @default null
+     * @hidden
      */
     editor: Editor | null;
     /**
@@ -290,8 +404,23 @@ declare interface BlockPopoverProps extends Omit<OverlayPositionerProps, 'placem
      */
     offset: number;
 }
-export { BlockPopoverProps }
-export { BlockPopoverProps as BlockPopoverProps_alias_1 }
+export { BlockHandlePopoverProps }
+export { BlockHandlePopoverProps as BlockHandlePopoverProps_alias_1 }
+
+/** @internal */
+declare const blockHandlePopoverProps: PropDeclarations<BlockHandlePopoverProps>;
+export { blockHandlePopoverProps }
+export { blockHandlePopoverProps as blockHandlePopoverProps_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type BlockPopoverContext = HoverState | null;
+
+/**
+ * @internal
+ */
+export declare const blockPopoverContext: Context<BlockPopoverContext>;
 
 export declare function calcResize(position: 'top' | 'right' | 'bottom' | 'left' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right', w: number, h: number, dx: number, dy: number, aspectRatio: number | null | undefined): [w: number, h: number];
 
@@ -299,321 +428,8 @@ export declare const default_alias: Options | Options[] | ((overrideOptions: Opt
 
 export { default_alias_1 }
 
-declare const defaultAutocompleteEmptyProps: {};
-export { defaultAutocompleteEmptyProps }
-export { defaultAutocompleteEmptyProps as defaultAutocompleteEmptyProps_alias_1 }
-
-declare const defaultAutocompleteItemProps: {
-    value: string;
-    onSelect: null;
-};
-export { defaultAutocompleteItemProps }
-export { defaultAutocompleteItemProps as defaultAutocompleteItemProps_alias_1 }
-
-declare const defaultAutocompleteListProps: {
-    filter: (options: {
-        query: string;
-        value: string;
-    }) => boolean;
-    editor: null;
-};
-export { defaultAutocompleteListProps }
-export { defaultAutocompleteListProps as defaultAutocompleteListProps_alias_1 }
-
-declare const defaultAutocompletePopoverProps: Readonly<{
-    editor: null;
-    regex: null;
-    onQueryChange: null;
-    onOpenChange: null;
-    placement: "bottom-start";
-    offset: 4;
-    inline: true;
-    hoist: true;
-    fitViewport: true;
-    boundary: HTMLBodyElement | "clippingAncestors";
-    overflowPadding: 8;
-    strategy: "absolute";
-    autoUpdate: true;
-    transform: false;
-    flip: false;
-    shift: false;
-    overlap: false;
-    sameWidth: false;
-    sameHeight: false;
-    hide: false;
-    rootBoundary: "viewport";
-    elementContext: "floating";
-    altBoundary: true;
-}>;
-export { defaultAutocompletePopoverProps }
-export { defaultAutocompletePopoverProps as defaultAutocompletePopoverProps_alias_1 }
-
-declare const defaultBlockDragHandleProps: Readonly<{
-    editor: null;
-}>;
-export { defaultBlockDragHandleProps }
-export { defaultBlockDragHandleProps as defaultBlockDragHandleProps_alias_1 }
-
-declare const defaultBlockHandleAddProps: Readonly<{
-    editor: null;
-}>;
-export { defaultBlockHandleAddProps }
-export { defaultBlockHandleAddProps as defaultBlockHandleAddProps_alias_1 }
-
-declare const defaultBlockHandleDraggableProps: Readonly<{
-    editor: null;
-}>;
-export { defaultBlockHandleDraggableProps }
-export { defaultBlockHandleDraggableProps as defaultBlockHandleDraggableProps_alias_1 }
-
-declare const defaultBlockHandlePopoverProps: Readonly<{
-    editor: null;
-    placement: "left-start";
-    offset: 4;
-    strategy: "absolute";
-    autoUpdate: true;
-    hoist: false;
-    transform: false;
-    flip: false;
-    shift: false;
-    overlap: false;
-    fitViewport: false;
-    sameWidth: false;
-    sameHeight: false;
-    inline: false;
-    hide: false;
-    boundary: "clippingAncestors";
-    rootBoundary: "viewport";
-    overflowPadding: 0;
-    elementContext: "floating";
-    altBoundary: true;
-}>;
-export { defaultBlockHandlePopoverProps }
-export { defaultBlockHandlePopoverProps as defaultBlockHandlePopoverProps_alias_1 }
-
-declare const defaultBlockPopoverProps: Readonly<{
-    editor: null;
-    placement: "left-start";
-    offset: 4;
-    strategy: "absolute";
-    autoUpdate: true;
-    hoist: false;
-    transform: false;
-    flip: false;
-    shift: false;
-    overlap: false;
-    fitViewport: false;
-    sameWidth: false;
-    sameHeight: false;
-    inline: false;
-    hide: false;
-    boundary: "clippingAncestors";
-    rootBoundary: "viewport";
-    overflowPadding: 0;
-    elementContext: "floating";
-    altBoundary: true;
-}>;
-export { defaultBlockPopoverProps }
-export { defaultBlockPopoverProps as defaultBlockPopoverProps_alias_1 }
-
-declare const defaultInlinePopoverProps: Readonly<{
-    editor: null;
-    defaultOpen: true;
-    open: false;
-    onOpenChange: null;
-    dismissOnEscape: true;
-    placement: "top";
-    offset: 12;
-    shift: true;
-    flip: true;
-    hide: true;
-    overlap: true;
-    inline: true;
-    overflowPadding: 8;
-    hoist: true;
-    boundary: never[];
-    strategy: "absolute";
-    autoUpdate: true;
-    transform: false;
-    fitViewport: false;
-    sameWidth: false;
-    sameHeight: false;
-    rootBoundary: "viewport";
-    elementContext: "floating";
-    altBoundary: true;
-}>;
-export { defaultInlinePopoverProps }
-export { defaultInlinePopoverProps as defaultInlinePopoverProps_alias_1 }
-
-export { defaultPopoverContentProps }
-export { defaultPopoverContentProps as defaultPopoverContentProps_alias_1 }
-
-export { defaultPopoverRootProps }
-export { defaultPopoverRootProps as defaultPopoverRootProps_alias_1 }
-
-export { defaultPopoverTriggerProps }
-export { defaultPopoverTriggerProps as defaultPopoverTriggerProps_alias_1 }
-
 export declare function defaultQueryBuilder(match: RegExpExecArray): string;
 
-declare const defaultResizableHandleProps: {
-    position: "bottom-right";
-};
-export { defaultResizableHandleProps }
-export { defaultResizableHandleProps as defaultResizableHandleProps_alias_1 }
-
-declare const defaultResizableRootProps: {
-    width: null;
-    height: null;
-    aspectRatio: null;
-    onSizeChangeStart: null;
-    onSizeChange: null;
-    onSizeChangeEnd: null;
-};
-export { defaultResizableRootProps }
-export { defaultResizableRootProps as defaultResizableRootProps_alias_1 }
-
-declare const defaultTableHandleColumnRootProps: Readonly<{
-    editor: null;
-    placement: "top";
-    strategy: "absolute";
-    autoUpdate: true;
-    hoist: false;
-    transform: false;
-    offset: null;
-    flip: false;
-    shift: false;
-    overlap: false;
-    fitViewport: false;
-    sameWidth: false;
-    sameHeight: false;
-    inline: false;
-    hide: false;
-    boundary: "clippingAncestors";
-    rootBoundary: "viewport";
-    overflowPadding: 0;
-    elementContext: "floating";
-    altBoundary: true;
-}>;
-export { defaultTableHandleColumnRootProps }
-export { defaultTableHandleColumnRootProps as defaultTableHandleColumnRootProps_alias_1 }
-
-declare const defaultTableHandleColumnTriggerProps: Readonly<{
-    editor: null;
-}>;
-export { defaultTableHandleColumnTriggerProps }
-export { defaultTableHandleColumnTriggerProps as defaultTableHandleColumnTriggerProps_alias_1 }
-
-declare const defaultTableHandlePopoverContentProps: Readonly<{
-    placement: "right-start";
-    offset: {
-        mainAxis: number;
-        crossAxis: number;
-    };
-    editor: null;
-    onKeydownHandlerAdd: null;
-    hoist: true;
-    flip: true;
-    shift: true;
-    overflowPadding: 4;
-    onEscapeKeyDown: null;
-    onPointerDownOutside: null;
-    onFocusOutside: null;
-    onInteractOutside: null;
-    strategy: "absolute";
-    autoUpdate: true;
-    transform: false;
-    overlap: false;
-    fitViewport: false;
-    sameWidth: false;
-    sameHeight: false;
-    inline: false;
-    hide: false;
-    boundary: "clippingAncestors";
-    rootBoundary: "viewport";
-    elementContext: "floating";
-    altBoundary: true;
-}>;
-export { defaultTableHandlePopoverContentProps }
-export { defaultTableHandlePopoverContentProps as defaultTableHandlePopoverContentProps_alias_1 }
-
-declare const defaultTableHandlePopoverItemProps: Readonly<{
-    disabled: false;
-    value: "";
-    query: "";
-    filter: ItemFilter;
-    onSelect: null;
-}>;
-export { defaultTableHandlePopoverItemProps }
-export { defaultTableHandlePopoverItemProps as defaultTableHandlePopoverItemProps_alias_1 }
-
-declare const defaultTableHandleRootProps: Readonly<{
-    editor: null;
-}>;
-export { defaultTableHandleRootProps }
-export { defaultTableHandleRootProps as defaultTableHandleRootProps_alias_1 }
-
-declare const defaultTableHandleRowRootProps: Readonly<{
-    editor: null;
-    placement: "left";
-    strategy: "absolute";
-    autoUpdate: true;
-    hoist: false;
-    transform: false;
-    offset: null;
-    flip: false;
-    shift: false;
-    overlap: false;
-    fitViewport: false;
-    sameWidth: false;
-    sameHeight: false;
-    inline: false;
-    hide: false;
-    boundary: "clippingAncestors";
-    rootBoundary: "viewport";
-    overflowPadding: 0;
-    elementContext: "floating";
-    altBoundary: true;
-}>;
-export { defaultTableHandleRowRootProps }
-export { defaultTableHandleRowRootProps as defaultTableHandleRowRootProps_alias_1 }
-
-declare const defaultTableHandleRowTriggerProps: Readonly<{
-    editor: null;
-}>;
-export { defaultTableHandleRowTriggerProps }
-export { defaultTableHandleRowTriggerProps as defaultTableHandleRowTriggerProps_alias_1 }
-
-declare const defaultTooltipContentProps: {
-    shift: true;
-    flip: true;
-    offset: number;
-    overflowPadding: number;
-    hoist: true;
-    boundary: never[];
-    strategy: "absolute";
-    placement: "top";
-    autoUpdate: true;
-    transform: false;
-    overlap: false;
-    fitViewport: false;
-    sameWidth: false;
-    sameHeight: false;
-    inline: false;
-    hide: false;
-    rootBoundary: "viewport";
-    elementContext: "floating";
-    altBoundary: true;
-};
-export { defaultTooltipContentProps }
-export { defaultTooltipContentProps as defaultTooltipContentProps_alias_1 }
-
-export { defaultTooltipRootProps }
-export { defaultTooltipRootProps as defaultTooltipRootProps_alias_1 }
-
-export { defaultTooltipTriggerProps }
-export { defaultTooltipTriggerProps as defaultTooltipTriggerProps_alias_1 }
-
 export declare function defineCustomElement(name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions): void;
 
 export declare function defineElementHoverHandler(handler: ElementHoverHandler): Union<readonly [PlainExtension, PlainExtension, PlainExtension]>;
@@ -622,6 +438,8 @@ export declare type ElementHoverHandler = (reference: VirtualElement | null, hov
 
 export declare function getHoveringCell(view: EditorView, event: MouseEvent): HoveringCellInfo | undefined;
 
+export declare function getStateWithDefaults<Props extends Record<string, any> = Record<string, any>>(state: Partial<SignalState<Props>>, props: PropDeclarations<Props>): SignalState<Props>;
+
 export declare function getVirtualSelectionElement(view: EditorView): ReferenceElement | undefined;
 
 export declare interface HoveringCellInfo {
@@ -646,16 +464,25 @@ declare class InlinePopoverElement extends InlinePopoverElement_base {
 export { InlinePopoverElement }
 export { InlinePopoverElement as InlinePopoverElement_alias_1 }
 
-declare const InlinePopoverElement_base: {
-    new (): BaseElement & InlinePopoverProps;
-    prototype: HTMLElement;
-};
+declare const InlinePopoverElement_base: BaseElementConstructor<InlinePopoverProps>;
+
+/** @internal */
+declare interface InlinePopoverEvents extends OverlayPositionerEvents_2 {
+}
+export { InlinePopoverEvents }
+export { InlinePopoverEvents as InlinePopoverEvents_alias_1 }
 
-declare interface InlinePopoverProps extends Omit<OverlayPositionerProps, 'placement' | 'offset'> {
+/** @internal */
+declare const inlinePopoverEvents: EventDeclarations<InlinePopoverEvents>;
+export { inlinePopoverEvents }
+export { inlinePopoverEvents as inlinePopoverEvents_alias_1 }
+
+declare interface InlinePopoverProps extends Omit<OverlayPositionerProps_2, 'placement' | 'offset'> {
     /**
      * The ProseKit editor instance.
      *
      * @default null
+     * @hidden
      */
     editor: Editor | null;
     /**
@@ -697,35 +524,40 @@ declare interface InlinePopoverProps extends Omit<OverlayPositionerProps, 'place
      *
      * @default "top"
      */
-    placement: OverlayPositionerProps['placement'];
+    placement: OverlayPositionerProps_2['placement'];
     /**
      * @default 12
      */
-    offset: OverlayPositionerProps['offset'];
+    offset: OverlayPositionerProps_2['offset'];
     /**
      * @default true
      */
-    flip: OverlayPositionerProps['flip'];
+    flip: OverlayPositionerProps_2['flip'];
     /**
      * @default true
      */
-    hide: OverlayPositionerProps['hide'];
+    hide: OverlayPositionerProps_2['hide'];
     /**
      * @default true
      */
-    overlap: OverlayPositionerProps['overlap'];
+    overlap: OverlayPositionerProps_2['overlap'];
     /**
      * @default true
      */
-    inline: OverlayPositionerProps['inline'];
+    inline: OverlayPositionerProps_2['inline'];
     /**
      * @default true
      */
-    hoist: OverlayPositionerProps['hoist'];
+    hoist: OverlayPositionerProps_2['hoist'];
 }
 export { InlinePopoverProps }
 export { InlinePopoverProps as InlinePopoverProps_alias_1 }
 
+/** @internal */
+declare const inlinePopoverProps: PropDeclarations<InlinePopoverProps>;
+export { inlinePopoverProps }
+export { inlinePopoverProps as inlinePopoverProps_alias_1 }
+
 export declare function isFinitePositiveNumber(value: unknown): value is number;
 
 export declare function isHoveringCellInfoEqual(a?: HoveringCellInfo | null, b?: HoveringCellInfo | null): boolean;
@@ -769,40 +601,70 @@ declare class PopoverContentElement extends PopoverContentElement_base {
 export { PopoverContentElement }
 export { PopoverContentElement as PopoverContentElement_alias_1 }
 
-declare const PopoverContentElement_base: {
-    new (): BaseElement & PopoverContentProps;
-    prototype: HTMLElement;
-};
+declare const PopoverContentElement_base: BaseElementConstructor<PopoverContentProps>;
 
+declare interface PopoverContentEvents extends PopoverContentEvents_2 {
+}
+export { PopoverContentEvents }
+export { PopoverContentEvents as PopoverContentEvents_alias_1 }
+
+export { popoverContentEvents }
+export { popoverContentEvents as popoverContentEvents_alias_1 }
+
+declare interface PopoverContentProps extends PopoverContentProps_2 {
+}
 export { PopoverContentProps }
 export { PopoverContentProps as PopoverContentProps_alias_1 }
 
+export { popoverContentProps }
+export { popoverContentProps as popoverContentProps_alias_1 }
+
 declare class PopoverRootElement extends PopoverRootElement_base {
 }
 export { PopoverRootElement }
 export { PopoverRootElement as PopoverRootElement_alias_1 }
 
-declare const PopoverRootElement_base: {
-    new (): BaseElement & PopoverRootProps;
-    prototype: HTMLElement;
-};
+declare const PopoverRootElement_base: BaseElementConstructor<PopoverRootProps>;
+
+declare interface PopoverRootEvents extends PopoverRootEvents_2 {
+}
+export { PopoverRootEvents }
+export { PopoverRootEvents as PopoverRootEvents_alias_1 }
+
+export { popoverRootEvents }
+export { popoverRootEvents as popoverRootEvents_alias_1 }
 
+declare interface PopoverRootProps extends PopoverRootProps_2 {
+}
 export { PopoverRootProps }
 export { PopoverRootProps as PopoverRootProps_alias_1 }
 
+export { popoverRootProps }
+export { popoverRootProps as popoverRootProps_alias_1 }
+
 declare class PopoverTriggerElement extends PopoverTriggerElement_base {
 }
 export { PopoverTriggerElement }
 export { PopoverTriggerElement as PopoverTriggerElement_alias_1 }
 
-declare const PopoverTriggerElement_base: {
-    new (): BaseElement & PopoverTriggerProps;
-    prototype: HTMLElement;
-};
+declare const PopoverTriggerElement_base: BaseElementConstructor<PopoverTriggerProps>;
+
+declare interface PopoverTriggerEvents extends PopoverTriggerEvents_2 {
+}
+export { PopoverTriggerEvents }
+export { PopoverTriggerEvents as PopoverTriggerEvents_alias_1 }
 
+export { popoverTriggerEvents }
+export { popoverTriggerEvents as popoverTriggerEvents_alias_1 }
+
+declare interface PopoverTriggerProps extends PopoverTriggerProps_2 {
+}
 export { PopoverTriggerProps }
 export { PopoverTriggerProps as PopoverTriggerProps_alias_1 }
 
+export { popoverTriggerProps }
+export { popoverTriggerProps as popoverTriggerProps_alias_1 }
+
 export declare const queryContext: Context<string>;
 
 declare class ResizableHandleElement extends ResizableHandleElement_base {
@@ -810,10 +672,18 @@ declare class ResizableHandleElement extends ResizableHandleElement_base {
 export { ResizableHandleElement }
 export { ResizableHandleElement as ResizableHandleElement_alias_1 }
 
-declare const ResizableHandleElement_base: {
-    new (): BaseElement & ResizableHandleProps;
-    prototype: HTMLElement;
-};
+declare const ResizableHandleElement_base: BaseElementConstructor<ResizableHandleProps>;
+
+/** @internal */
+declare interface ResizableHandleEvents {
+}
+export { ResizableHandleEvents }
+export { ResizableHandleEvents as ResizableHandleEvents_alias_1 }
+
+/** @internal */
+declare const resizableHandleEvents: EventDeclarations<ResizableHandleEvents>;
+export { resizableHandleEvents }
+export { resizableHandleEvents as resizableHandleEvents_alias_1 }
 
 declare interface ResizableHandleProps {
     /**
@@ -826,36 +696,49 @@ declare interface ResizableHandleProps {
 export { ResizableHandleProps }
 export { ResizableHandleProps as ResizableHandleProps_alias_1 }
 
+/** @internal */
+declare const resizableHandleProps: PropDeclarations<ResizableHandleProps>;
+export { resizableHandleProps }
+export { resizableHandleProps as resizableHandleProps_alias_1 }
+
 declare class ResizableRootElement extends ResizableRootElement_base {
 }
 export { ResizableRootElement }
 export { ResizableRootElement as ResizableRootElement_alias_1 }
 
-declare const ResizableRootElement_base: {
-    new (): BaseElement & ResizableRootProps;
-    prototype: HTMLElement;
-};
+declare const ResizableRootElement_base: BaseElementConstructor<ResizableRootProps>;
 
-declare interface ResizableRootProps {
-    width: number | null;
-    height: number | null;
-    aspectRatio: number | null;
-    onSizeChangeStart: ((size: {
-        width: number;
-        height: number;
-    }) => void) | null;
-    onSizeChange: ((size: {
+declare interface ResizableRootEvents {
+    resizeStart: CustomEvent<{
         width: number;
         height: number;
-    }) => void) | null;
-    onSizeChangeEnd: ((size: {
+    }>;
+    resizeEnd: CustomEvent<{
         width: number;
         height: number;
-    }) => void) | null;
+    }>;
+}
+export { ResizableRootEvents }
+export { ResizableRootEvents as ResizableRootEvents_alias_1 }
+
+/** @internal */
+declare const resizableRootEvents: EventDeclarations<ResizableRootEvents>;
+export { resizableRootEvents }
+export { resizableRootEvents as resizableRootEvents_alias_1 }
+
+declare interface ResizableRootProps {
+    width: number | null;
+    height: number | null;
+    aspectRatio: number | null;
 }
 export { ResizableRootProps }
 export { ResizableRootProps as ResizableRootProps_alias_1 }
 
+/** @internal */
+declare const resizableRootProps: PropDeclarations<ResizableRootProps>;
+export { resizableRootProps }
+export { resizableRootProps as resizableRootProps_alias_1 }
+
 declare type TableCommandsExtension = ReturnType<typeof defineTableCommands>;
 
 declare type TableCommandsExtension_2 = ReturnType<typeof defineTableCommands>;
@@ -865,16 +748,25 @@ declare class TableHandleColumnRootElement extends TableHandleColumnRootElement_
 export { TableHandleColumnRootElement }
 export { TableHandleColumnRootElement as TableHandleColumnRootElement_alias_1 }
 
-declare const TableHandleColumnRootElement_base: {
-    new (): BaseElement & TableHandleColumnRootProps;
-    prototype: HTMLElement;
-};
+declare const TableHandleColumnRootElement_base: BaseElementConstructor<TableHandleColumnRootProps>;
 
-declare interface TableHandleColumnRootProps extends Omit<OverlayPositionerProps, 'placement'> {
+/** @internal */
+declare interface TableHandleColumnRootEvents extends OverlayPositionerEvents_2 {
+}
+export { TableHandleColumnRootEvents }
+export { TableHandleColumnRootEvents as TableHandleColumnRootEvents_alias_1 }
+
+/** @internal */
+declare const tableHandleColumnRootEvents: EventDeclarations<TableHandleColumnRootEvents>;
+export { tableHandleColumnRootEvents }
+export { tableHandleColumnRootEvents as tableHandleColumnRootEvents_alias_1 }
+
+declare interface TableHandleColumnRootProps extends Omit<OverlayPositionerProps_2, 'placement'> {
     /**
      * The ProseKit editor instance.
      *
      * @default null
+     * @hidden
      */
     editor: Editor | null;
     /**
@@ -887,15 +779,28 @@ declare interface TableHandleColumnRootProps extends Omit<OverlayPositionerProps
 export { TableHandleColumnRootProps }
 export { TableHandleColumnRootProps as TableHandleColumnRootProps_alias_1 }
 
+/** @internal */
+declare const tableHandleColumnRootProps: PropDeclarations<TableHandleColumnRootProps>;
+export { tableHandleColumnRootProps }
+export { tableHandleColumnRootProps as tableHandleColumnRootProps_alias_1 }
+
 declare class TableHandleColumnTriggerElement extends TableHandleColumnTriggerElement_base {
 }
 export { TableHandleColumnTriggerElement }
 export { TableHandleColumnTriggerElement as TableHandleColumnTriggerElement_alias_1 }
 
-declare const TableHandleColumnTriggerElement_base: {
-    new (): BaseElement & TableHandleColumnTriggerProps;
-    prototype: HTMLElement;
-};
+declare const TableHandleColumnTriggerElement_base: BaseElementConstructor<TableHandleColumnTriggerProps>;
+
+/** @internal */
+declare interface TableHandleColumnTriggerEvents {
+}
+export { TableHandleColumnTriggerEvents }
+export { TableHandleColumnTriggerEvents as TableHandleColumnTriggerEvents_alias_1 }
+
+/** @internal */
+declare const tableHandleColumnTriggerEvents: EventDeclarations<TableHandleColumnTriggerEvents>;
+export { tableHandleColumnTriggerEvents }
+export { tableHandleColumnTriggerEvents as tableHandleColumnTriggerEvents_alias_1 }
 
 declare interface TableHandleColumnTriggerProps {
     editor: Editor<TableCommandsExtension> | null;
@@ -903,15 +808,27 @@ declare interface TableHandleColumnTriggerProps {
 export { TableHandleColumnTriggerProps }
 export { TableHandleColumnTriggerProps as TableHandleColumnTriggerProps_alias_1 }
 
+/** @internal */
+declare const tableHandleColumnTriggerProps: PropDeclarations<TableHandleColumnTriggerProps>;
+export { tableHandleColumnTriggerProps }
+export { tableHandleColumnTriggerProps as tableHandleColumnTriggerProps_alias_1 }
+
 declare class TableHandlePopoverContentElement extends TableHandlePopoverContentElement_base {
 }
 export { TableHandlePopoverContentElement }
 export { TableHandlePopoverContentElement as TableHandlePopoverContentElement_alias_1 }
 
-declare const TableHandlePopoverContentElement_base: {
-    new (): BaseElement & TableHandlePopoverContentProps;
-    prototype: HTMLElement;
-};
+declare const TableHandlePopoverContentElement_base: BaseElementConstructor<TableHandlePopoverContentProps>;
+
+declare interface TableHandlePopoverContentEvents extends MenuContentEvents {
+}
+export { TableHandlePopoverContentEvents }
+export { TableHandlePopoverContentEvents as TableHandlePopoverContentEvents_alias_1 }
+
+/** @internal */
+declare const tableHandlePopoverContentEvents: EventDeclarations<TableHandlePopoverContentEvents>;
+export { tableHandlePopoverContentEvents }
+export { tableHandlePopoverContentEvents as tableHandlePopoverContentEvents_alias_1 }
 
 declare interface TableHandlePopoverContentProps extends Omit<MenuContentProps, 'placement' | 'offset'> {
     /**
@@ -927,22 +844,38 @@ declare interface TableHandlePopoverContentProps extends Omit<MenuContentProps,
 export { TableHandlePopoverContentProps }
 export { TableHandlePopoverContentProps as TableHandlePopoverContentProps_alias_1 }
 
+/** @internal */
+declare const tableHandlePopoverContentProps: PropDeclarations<TableHandlePopoverContentProps>;
+export { tableHandlePopoverContentProps }
+export { tableHandlePopoverContentProps as tableHandlePopoverContentProps_alias_1 }
+
 declare class TableHandlePopoverItemElement extends TableHandlePopoverItemElement_base {
 }
 export { TableHandlePopoverItemElement }
 export { TableHandlePopoverItemElement as TableHandlePopoverItemElement_alias_1 }
 
-declare const TableHandlePopoverItemElement_base: {
-    new (): BaseElement & TableHandlePopoverItemProps;
-    prototype: HTMLElement;
-};
+declare const TableHandlePopoverItemElement_base: BaseElementConstructor<TableHandlePopoverItemProps>;
+
+declare interface TableHandlePopoverItemEvents extends MenuItemEvents {
+}
+export { TableHandlePopoverItemEvents }
+export { TableHandlePopoverItemEvents as TableHandlePopoverItemEvents_alias_1 }
+
+/** @internal */
+declare const tableHandlePopoverItemEvents: EventDeclarations<TableHandlePopoverItemEvents>;
+export { tableHandlePopoverItemEvents }
+export { tableHandlePopoverItemEvents as tableHandlePopoverItemEvents_alias_1 }
 
 declare interface TableHandlePopoverItemProps extends MenuItemProps {
-    disabled?: boolean;
 }
 export { TableHandlePopoverItemProps }
 export { TableHandlePopoverItemProps as TableHandlePopoverItemProps_alias_1 }
 
+/** @internal */
+declare const tableHandlePopoverItemProps: PropDeclarations<TableHandlePopoverItemProps>;
+export { tableHandlePopoverItemProps }
+export { tableHandlePopoverItemProps as tableHandlePopoverItemProps_alias_1 }
+
 /**
  * @internal
  */
@@ -958,37 +891,60 @@ declare class TableHandleRootElement extends TableHandleRootElement_base {
 export { TableHandleRootElement }
 export { TableHandleRootElement as TableHandleRootElement_alias_1 }
 
-declare const TableHandleRootElement_base: {
-    new (): BaseElement & TableHandleRootProps;
-    prototype: HTMLElement;
-};
+declare const TableHandleRootElement_base: BaseElementConstructor<TableHandleRootProps>;
+
+/** @internal */
+declare interface TableHandleRootEvents {
+}
+export { TableHandleRootEvents }
+export { TableHandleRootEvents as TableHandleRootEvents_alias_1 }
+
+/** @internal */
+declare const tableHandleRootEvents: EventDeclarations<TableHandleRootEvents>;
+export { tableHandleRootEvents }
+export { tableHandleRootEvents as tableHandleRootEvents_alias_1 }
 
 declare interface TableHandleRootProps {
     /**
      * The ProseKit editor instance.
      *
      * @default null
+     * @hidden
      */
     editor: Editor | null;
 }
 export { TableHandleRootProps }
 export { TableHandleRootProps as TableHandleRootProps_alias_1 }
 
+/** @internal */
+declare const tableHandleRootProps: PropDeclarations<TableHandleRootProps>;
+export { tableHandleRootProps }
+export { tableHandleRootProps as tableHandleRootProps_alias_1 }
+
 declare class TableHandleRowRootElement extends TableHandleRowRootElement_base {
 }
 export { TableHandleRowRootElement }
 export { TableHandleRowRootElement as TableHandleRowRootElement_alias_1 }
 
-declare const TableHandleRowRootElement_base: {
-    new (): BaseElement & TableHandleRowRootProps;
-    prototype: HTMLElement;
-};
+declare const TableHandleRowRootElement_base: BaseElementConstructor<TableHandleRowRootProps>;
+
+/** @internal */
+declare interface TableHandleRowRootEvents extends OverlayPositionerEvents_2 {
+}
+export { TableHandleRowRootEvents }
+export { TableHandleRowRootEvents as TableHandleRowRootEvents_alias_1 }
+
+/** @internal */
+declare const tableHandleRowRootEvents: EventDeclarations<TableHandleRowRootEvents>;
+export { tableHandleRowRootEvents }
+export { tableHandleRowRootEvents as tableHandleRowRootEvents_alias_1 }
 
-declare interface TableHandleRowRootProps extends Omit<OverlayPositionerProps, 'placement'> {
+declare interface TableHandleRowRootProps extends Omit<OverlayPositionerProps_2, 'placement'> {
     /**
      * The ProseKit editor instance.
      *
      * @default null
+     * @hidden
      */
     editor: Editor | null;
     /**
@@ -1001,15 +957,28 @@ declare interface TableHandleRowRootProps extends Omit<OverlayPositionerProps, '
 export { TableHandleRowRootProps }
 export { TableHandleRowRootProps as TableHandleRowRootProps_alias_1 }
 
+/** @internal */
+declare const tableHandleRowRootProps: PropDeclarations<TableHandleRowRootProps>;
+export { tableHandleRowRootProps }
+export { tableHandleRowRootProps as tableHandleRowRootProps_alias_1 }
+
 declare class TableHandleRowTriggerElement extends TableHandleRowTriggerElement_base {
 }
 export { TableHandleRowTriggerElement }
 export { TableHandleRowTriggerElement as TableHandleRowTriggerElement_alias_1 }
 
-declare const TableHandleRowTriggerElement_base: {
-    new (): BaseElement & TableHandleRowTriggerProps;
-    prototype: HTMLElement;
-};
+declare const TableHandleRowTriggerElement_base: BaseElementConstructor<TableHandleRowTriggerProps>;
+
+declare interface TableHandleRowTriggerEvents {
+    select: CustomEvent<void>;
+}
+export { TableHandleRowTriggerEvents }
+export { TableHandleRowTriggerEvents as TableHandleRowTriggerEvents_alias_1 }
+
+/** @internal */
+declare const tableHandleRowTriggerEvents: EventDeclarations<TableHandleRowTriggerEvents>;
+export { tableHandleRowTriggerEvents }
+export { tableHandleRowTriggerEvents as tableHandleRowTriggerEvents_alias_1 }
 
 declare interface TableHandleRowTriggerProps {
     editor: Editor<TableCommandsExtension_2> | null;
@@ -1017,6 +986,11 @@ declare interface TableHandleRowTriggerProps {
 export { TableHandleRowTriggerProps }
 export { TableHandleRowTriggerProps as TableHandleRowTriggerProps_alias_1 }
 
+/** @internal */
+declare const tableHandleRowTriggerProps: PropDeclarations<TableHandleRowTriggerProps>;
+export { tableHandleRowTriggerProps }
+export { tableHandleRowTriggerProps as tableHandleRowTriggerProps_alias_1 }
+
 /**
  * @internal
  */
@@ -1027,63 +1001,124 @@ declare class TooltipContentElement extends TooltipContentElement_base {
 export { TooltipContentElement }
 export { TooltipContentElement as TooltipContentElement_alias_1 }
 
-declare const TooltipContentElement_base: {
-    new (): BaseElement & TooltipContentProps;
-    prototype: HTMLElement;
-};
+declare const TooltipContentElement_base: BaseElementConstructor<TooltipContentProps>;
+
+declare interface TooltipContentEvents extends TooltipContentEvents_2 {
+}
+export { TooltipContentEvents }
+export { TooltipContentEvents as TooltipContentEvents_alias_1 }
 
+export { tooltipContentEvents }
+export { tooltipContentEvents as tooltipContentEvents_alias_1 }
+
+declare interface TooltipContentProps extends TooltipContentProps_2 {
+}
 export { TooltipContentProps }
 export { TooltipContentProps as TooltipContentProps_alias_1 }
 
+declare const tooltipContentProps: {
+    shift: {
+        default: boolean;
+    };
+    flip: {
+        default: boolean;
+    };
+    offset: {
+        default: number;
+    };
+    overflowPadding: {
+        default: number;
+    };
+    hoist: {
+        default: boolean;
+    };
+    boundary: {
+        default: never[];
+    };
+    inline: PropDeclaration<boolean>;
+    placement: PropDeclaration<Placement>;
+    fitViewport: PropDeclaration<boolean>;
+    strategy: PropDeclaration<"fixed" | "absolute">;
+    autoUpdate: PropDeclaration<boolean | AutoUpdateOptions>;
+    transform: PropDeclaration<boolean>;
+    overlap: PropDeclaration<boolean>;
+    sameWidth: PropDeclaration<boolean>;
+    sameHeight: PropDeclaration<boolean>;
+    hide: PropDeclaration<boolean>;
+    rootBoundary: PropDeclaration<RootBoundary>;
+    elementContext: PropDeclaration<ElementContext>;
+    altBoundary: PropDeclaration<boolean>;
+};
+export { tooltipContentProps }
+export { tooltipContentProps as tooltipContentProps_alias_1 }
+
 declare class TooltipRootElement extends TooltipRootElement_base {
 }
 export { TooltipRootElement }
 export { TooltipRootElement as TooltipRootElement_alias_1 }
 
-declare const TooltipRootElement_base: {
-    new (): BaseElement & TooltipRootProps;
-    prototype: HTMLElement;
-};
+declare const TooltipRootElement_base: BaseElementConstructor<TooltipRootProps>;
+
+declare interface TooltipRootEvents extends TooltipRootEvents_2 {
+}
+export { TooltipRootEvents }
+export { TooltipRootEvents as TooltipRootEvents_alias_1 }
 
+export { tooltipRootEvents }
+export { tooltipRootEvents as tooltipRootEvents_alias_1 }
+
+declare interface TooltipRootProps extends TooltipRootProps_2 {
+}
 export { TooltipRootProps }
 export { TooltipRootProps as TooltipRootProps_alias_1 }
 
+export { tooltipRootProps }
+export { tooltipRootProps as tooltipRootProps_alias_1 }
+
 declare class TooltipTriggerElement extends TooltipTriggerElement_base {
 }
 export { TooltipTriggerElement }
 export { TooltipTriggerElement as TooltipTriggerElement_alias_1 }
 
-declare const TooltipTriggerElement_base: {
-    new (): BaseElement & TooltipTriggerProps;
-    prototype: HTMLElement;
-};
+declare const TooltipTriggerElement_base: BaseElementConstructor<TooltipTriggerProps>;
+
+declare interface TooltipTriggerEvents extends TooltipTriggerEvents_2 {
+}
+export { TooltipTriggerEvents }
+export { TooltipTriggerEvents as TooltipTriggerEvents_alias_1 }
+
+export { tooltipTriggerEvents }
+export { tooltipTriggerEvents as tooltipTriggerEvents_alias_1 }
 
+declare interface TooltipTriggerProps extends TooltipTriggerProps_2 {
+}
 export { TooltipTriggerProps }
 export { TooltipTriggerProps as TooltipTriggerProps_alias_1 }
 
-export declare function useAutocompleteEmpty(element: ConnectableElement): void;
-
-export declare function useAutocompleteItem(element: ConnectableElement, state: SignalState<AutocompleteItemProps>): void;
+export { tooltipTriggerProps }
+export { tooltipTriggerProps as tooltipTriggerProps_alias_1 }
 
-export declare function useAutocompleteList(element: ConnectableElement, state: SignalState<AutocompleteListProps>): void;
+export declare const useAutocompleteEmpty: typeof useListboxEmpty;
 
-export declare function useAutocompletePopover(host: ConnectableElement, state: SignalState<AutocompletePopoverProps>): void;
+export declare function useAutocompleteItem(element: ConnectableElement, { state, emit }: SetupOptions<AutocompleteItemProps, AutocompleteItemEvents>): void;
 
-/**
- * @deprecated Use `useBlockHandleDraggable` instead.
- */
-export declare function useBlockDragHandle(host: ConnectableElement, state: SignalState<BlockDragHandleProps>): void;
+export declare function useAutocompleteList(element: ConnectableElement, { state, emit }: SetupOptions<AutocompleteListProps, AutocompleteListEvents>): void;
 
-export declare function useBlockHandleAdd(host: ConnectableElement, state: SignalState<BlockHandleAddProps>): void;
+export declare function useAutocompletePopover(host: ConnectableElement, { state }: {
+    state: SignalState<AutocompletePopoverProps>;
+}): void;
 
-export declare function useBlockHandleDraggable(host: ConnectableElement, state: SignalState<BlockHandleDraggableProps>): void;
+export declare function useBlockHandleAdd(host: ConnectableElement, { state }: {
+    state: SignalState<BlockHandleAddProps>;
+}): void;
 
-export declare function useBlockHandlePopover(host: ConnectableElement, state: SignalState<BlockHandlePopoverProps>): void;
+export declare function useBlockHandleDraggable(host: ConnectableElement, { state }: {
+    state: SignalState<BlockHandleDraggableProps>;
+}): void;
 
-/**
- * @deprecated Use `useBlockHandlePopover` instead.
- */
-export declare function useBlockPopover(host: ConnectableElement, state: SignalState<BlockPopoverProps>): void;
+export declare function useBlockHandlePopover(host: ConnectableElement, { state }: {
+    state: SignalState<BlockHandlePopoverProps>;
+}): void;
 
 export declare function useEditorExtension(host: ConnectableElement, editor: ReadonlySignal<Editor | null>, extension: Extension): void;
 
@@ -1101,7 +1136,9 @@ export declare function useEditorUpdateEvent(host: ConnectableElement, editor: R
 
 export declare function useFirstRendering(host: ConnectableElement): ReadonlySignal<boolean>;
 
-export declare function useInlinePopover(host: ConnectableElement, state: SignalState<InlinePopoverProps>): void;
+export declare function useInlinePopover(host: ConnectableElement, { state }: {
+    state: SignalState<InlinePopoverProps>;
+}): void;
 
 export declare function useKeymap(host: ConnectableElement, editor: ReadonlySignal<Editor | null>, keymap: Keymap): void;
 
@@ -1111,23 +1148,31 @@ export { usePopoverRoot }
 
 export { usePopoverTrigger }
 
-export declare function useResizableHandle(host: ConnectableElement, state: SignalState<ResizableHandleProps>): void;
+export declare function useResizableHandle(host: ConnectableElement, { state }: {
+    state: SignalState<ResizableHandleProps>;
+}): void;
 
-export declare function useResizableRoot(host: ConnectableElement, state: SignalState<ResizableRootProps>): void;
+export declare function useResizableRoot(host: ConnectableElement, { state, emit }: SetupOptions<ResizableRootProps, ResizableRootEvents>): void;
 
-export declare function useTableHandleColumnRoot(host: ConnectableElement, state: SignalState<TableHandleColumnRootProps>): void;
+export declare function useTableHandleColumnRoot(host: ConnectableElement, { state }: {
+    state: SignalState<TableHandleColumnRootProps>;
+}): void;
 
-export declare function useTableHandleColumnTrigger(host: ConnectableElement, state: SignalState<TableHandleColumnTriggerProps>): void;
+export declare function useTableHandleColumnTrigger(host: ConnectableElement, { state }: {
+    state: SignalState<TableHandleColumnTriggerProps>;
+}): void;
 
-export declare function useTableHandlePopoverContent(host: ConnectableElement, state: SignalState<TableHandlePopoverContentProps>): void;
+export declare function useTableHandlePopoverContent(host: ConnectableElement, { state, emit, }: SetupOptions<TableHandlePopoverContentProps, TableHandlePopoverContentEvents>): void;
 
-export declare function useTableHandlePopoverItem(element: ConnectableElement, state: SignalState<TableHandlePopoverItemProps>): void;
+export declare function useTableHandlePopoverItem(element: ConnectableElement, { state, emit, }: SetupOptions<TableHandlePopoverItemProps, TableHandlePopoverItemEvents>): void;
 
-export declare function useTableHandleRoot(host: ConnectableElement, state: SignalState<TableHandleRootProps>): void;
+export declare function useTableHandleRoot(host: ConnectableElement, { state }: {
+    state: SignalState<TableHandleRootProps>;
+}): void;
 
-export declare function useTableHandleRowRoot(host: ConnectableElement, state: SignalState<TableHandleRowRootProps>): void;
+export declare function useTableHandleRowRoot(host: ConnectableElement, { state }: SetupOptions<TableHandleRowRootProps, TableHandleRowRootEvents>): void;
 
-export declare function useTableHandleRowTrigger(host: ConnectableElement, state: SignalState<TableHandleRowTriggerProps>): void;
+export declare function useTableHandleRowTrigger(host: ConnectableElement, { state, }: SetupOptions<TableHandleRowTriggerProps, TableHandleRowTriggerEvents>): void;
 
 export { useTooltipContent }