@notectl/core 0.0.11 → 1.0.2

package/dist/index.d.ts

@@ -18,6 +18,58 @@ export declare interface AddMarkStep {
     readonly path?: readonly BlockId[];
 }
 
+export declare const ALIGNMENT_ICONS: Readonly<Record<BlockAlignment, string>>;
+
+declare interface AlignmentConfig {
+    /** Which alignments to expose. Defaults to all four. */
+    readonly alignments: readonly BlockAlignment[];
+    /** Block types that support alignment. Defaults to paragraph + heading + title + subtitle + table_cell + image. */
+    readonly alignableTypes: readonly string[];
+    /** Per-type default alignment (e.g. `{ image: 'center' }`). Falls back to `'left'`. */
+    readonly defaults: Readonly<Record<string, BlockAlignment>>;
+    /** When true, a separator is rendered after the toolbar item. */
+    readonly separatorAfter?: boolean;
+}
+export { AlignmentConfig }
+export { AlignmentConfig as TextAlignmentConfig }
+
+declare class AlignmentPlugin implements Plugin_2 {
+    readonly id = "alignment";
+    readonly name = "Alignment";
+    readonly priority = 90;
+    private readonly config;
+    private alignableTypes;
+    constructor(config?: Partial<AlignmentConfig>);
+    init(context: PluginContext): void;
+    /**
+     * Patches existing NodeSpecs for alignable block types to support the
+     * `align` attribute and render it as an inline style. Skips types
+     * that already define an `align` attribute in their spec.
+     */
+    private patchNodeSpecs;
+    private registerCommands;
+    private registerKeymaps;
+    private registerToolbarItem;
+    /**
+     * Preserves the `align` attribute when other plugins change the block
+     * type (e.g. paragraph → heading) via `setBlockType`, which replaces attrs.
+     */
+    private registerMiddleware;
+    /**
+     * Gets the selected block, handling both TextSelection and NodeSelection.
+     */
+    private getSelectedBlock;
+    /**
+     * Gets the block ID of the selected block, handling both selection types.
+     */
+    private getSelectedBlockId;
+    private setAlignment;
+    private isNonDefaultAlignment;
+    private isAlignable;
+}
+export { AlignmentPlugin }
+export { AlignmentPlugin as TextAlignmentPlugin }
+
 /** Applies a single step to a document and returns the new document. */
 export declare function applyStep(doc: Document_2, step: Step): Document_2;
 
@@ -25,6 +77,10 @@ export declare interface AttrSpec {
     readonly default?: string | number | boolean;
 }
 
+declare type BlockAlignment = 'left' | 'center' | 'right' | 'justify';
+export { BlockAlignment }
+export { BlockAlignment as TextAlignment }
+
 export declare interface BlockAttrs {
     readonly [key: string]: string | number | boolean;
 }
@@ -66,6 +122,21 @@ export declare class BlockquotePlugin implements Plugin_2 {
     private setBlockType;
 }
 
+export declare interface BlockTypePickerEntry {
+    /** Unique identifier, e.g. 'heading-1', 'footer'. */
+    readonly id: string;
+    /** Display label shown in the picker, e.g. 'Heading 1'. */
+    readonly label: string;
+    /** Command to execute when the entry is selected. */
+    readonly command: string;
+    /** Sort order — lower values appear first. */
+    readonly priority: number;
+    /** Optional styling for the label in the picker dropdown. */
+    readonly style?: PickerEntryStyle;
+    /** Returns true when this entry matches the current block type. */
+    isActive(state: EditorState): boolean;
+}
+
 export declare interface BoldMark extends Mark {
     readonly type: MarkTypeName & 'bold';
 }
@@ -93,6 +164,151 @@ export declare interface CellRange {
 declare type ChildNode_2 = TextNode | InlineNode | BlockNode;
 export { ChildNode_2 as ChildNode }
 
+export declare class ClipboardHandler {
+    private readonly element;
+    private readonly getState;
+    private readonly dispatch;
+    private readonly schemaRegistry?;
+    private readonly syncSelection?;
+    private readonly handleCopy;
+    private readonly handleCut;
+    constructor(element: HTMLElement, options: ClipboardHandlerOptions);
+    private onCopy;
+    private onCut;
+    private writeNodeSelectionToClipboard;
+    private writeTextSelectionToClipboard;
+    /** Serializes a range of inline content within a block to an HTML string. */
+    private serializeBlockRangeToHTML;
+    /** Wraps escaped text in mark HTML tags using MarkSpec.toHTMLString when available. */
+    private serializeTextWithMarks;
+    destroy(): void;
+}
+
+declare interface ClipboardHandlerOptions {
+    readonly getState: GetStateFn;
+    readonly dispatch: DispatchFn;
+    readonly schemaRegistry?: SchemaRegistry;
+    /** Force-sync DOM selection to state (selectionchange may fire async). */
+    readonly syncSelection?: () => void;
+}
+
+export declare const CODE_BLOCK_SERVICE_KEY: ServiceKey<CodeBlockService>;
+
+export declare interface CodeBlockConfig {
+    readonly highlighter?: SyntaxHighlighter;
+    readonly defaultLanguage?: string;
+    readonly useSpaces?: boolean;
+    readonly spaceCount?: number;
+    readonly showCopyButton?: boolean;
+    readonly separatorAfter?: boolean;
+    /** Default body background color (overrides --notectl-code-block-bg). */
+    readonly background?: string;
+    /** Default header background color (overrides --notectl-code-block-header-bg). */
+    readonly headerBackground?: string;
+    /** Default text color (overrides --notectl-code-block-color). */
+    readonly textColor?: string;
+    /** Default header/label text color (overrides --notectl-code-block-header-color). */
+    readonly headerColor?: string;
+    /** Customize keyboard bindings for code block actions. */
+    readonly keymap?: CodeBlockKeymap;
+}
+
+/**
+ * Configurable keyboard bindings for CodeBlockPlugin actions.
+ * Omit a slot to use the default; set to `null` to disable the binding.
+ *
+ * Key descriptor format: `'Mod-Enter'`, `'Mod-Shift-M'`, etc.
+ * `Mod` resolves to Cmd on macOS, Ctrl on Windows/Linux.
+ */
+export declare interface CodeBlockKeymap {
+    /**
+     * Insert a new paragraph below the code block and move the cursor there.
+     * @default 'Mod-Enter'
+     */
+    readonly insertAfter?: string | null;
+    /**
+     * Toggle the current block between code block and paragraph.
+     * @default 'Mod-Shift-M'
+     */
+    readonly toggle?: string | null;
+}
+
+export declare class CodeBlockPlugin implements Plugin_2 {
+    readonly id = "code-block";
+    readonly name = "Code Block";
+    readonly priority = 36;
+    private readonly config;
+    private readonly resolvedKeymap;
+    private context;
+    constructor(config?: Partial<CodeBlockConfig>);
+    init(context: PluginContext): void;
+    destroy(): void;
+    onStateChange(oldState: EditorState, newState: EditorState, _tr: Transaction): void;
+    decorations(state: EditorState): DecorationSet;
+    private registerNodeSpec;
+    private registerNodeView;
+    private registerCommands;
+    private registerKeymaps;
+    private registerInputRule;
+    private registerToolbarItem;
+    private registerMiddleware;
+    private registerService;
+    private patchTableCellContent;
+    /**
+     * Handles Backspace at the start of a code block.
+     * Converts the code block back to a paragraph, preserving text.
+     */
+    private handleBackspace;
+    private handleEnter;
+    private handleTab;
+    private handleShiftTab;
+    private handleEscape;
+    /**
+     * Handles ArrowDown at the last line of a code block.
+     * Exits to the next block or creates a paragraph below.
+     */
+    private handleArrowDown;
+    /**
+     * Handles ArrowUp at the first line of a code block.
+     * Exits to the previous block.
+     */
+    private handleArrowUp;
+    /**
+     * Handles ArrowRight at the end of a code block.
+     * Exits to the next block or creates a paragraph below.
+     */
+    private handleArrowRight;
+    /**
+     * Handles ArrowLeft at the start of a code block.
+     * Exits to the previous block at end.
+     */
+    private handleArrowLeft;
+    /**
+     * Handles Mod+Enter: always creates a paragraph below and moves cursor there.
+     */
+    private handleModEnter;
+    private setBlockFocused;
+    private toggleCodeBlock;
+    private insertCodeBlock;
+    private exitOnDoubleEnter;
+    private insertParagraphAfter;
+    private setAttr;
+    /**
+     * Strips all marks from a block's inline content.
+     * Used when converting to code_block so no formatting carries over.
+     */
+    private stripAllMarks;
+}
+
+export declare interface CodeBlockService {
+    setLanguage(blockId: BlockId, language: string): void;
+    getLanguage(blockId: BlockId): string;
+    setBackground(blockId: BlockId, color: string): void;
+    getBackground(blockId: BlockId): string;
+    isCodeBlock(blockId: BlockId): boolean;
+    getSupportedLanguages(): readonly string[];
+}
+
 export declare interface CommandEntry {
     readonly name: string;
     readonly handler: CommandHandler;
@@ -154,6 +370,15 @@ export declare function createSelection(anchor: Position, head: Position): Selec
 /** Creates a new {@link TextNode}. */
 export declare function createTextNode(text: string, marks?: readonly Mark[]): TextNode;
 
+/** Creates a custom theme by extending a base theme with partial overrides. */
+export declare function createTheme(base: Theme, overrides: PartialTheme): Theme;
+
+/** Creates a CSSStyleSheet populated with theme CSS variables. */
+export declare function createThemeStyleSheet(theme: Theme): CSSStyleSheet;
+
+/** Built-in dark theme. */
+export declare const DARK_THEME: Theme;
+
 export declare type Decoration = InlineDecoration | NodeDecoration | WidgetDecoration;
 
 export declare interface DecorationAttrs {
@@ -228,6 +453,8 @@ export declare interface DeleteTextStep {
     readonly path?: readonly BlockId[];
 }
 
+declare type DispatchFn = (tr: Transaction) => void;
+
 declare interface Document_2 {
     readonly children: readonly BlockNode[];
 }
@@ -502,6 +729,9 @@ export declare class FontSizePlugin implements Plugin_2 {
  */
 export declare function formatShortcut(binding: string): string;
 
+/** Generates CSS text with all theme custom properties on :host. */
+export declare function generateThemeCSS(theme: Theme): string;
+
 /** Returns only the BlockNode children of a block. */
 export declare function getBlockChildren(node: BlockNode): readonly BlockNode[];
 
@@ -527,6 +757,8 @@ export declare function getContentAtOffset(block: BlockNode, offset: number): {
 /** Returns the inline content children (TextNode | InlineNode) of a block. */
 export declare function getInlineChildren(node: BlockNode): readonly (TextNode | InlineNode)[];
 
+declare type GetStateFn = () => EditorState;
+
 /** Returns only the TextNode children of a block. */
 export declare function getTextChildren(node: BlockNode): readonly TextNode[];
 
@@ -536,6 +768,16 @@ export declare interface GridPickerConfig {
     onSelect(rows: number, cols: number): void;
 }
 
+export declare class HardBreakPlugin implements Plugin_2 {
+    readonly id = "hard-break";
+    readonly name = "Hard Break";
+    readonly priority = 10;
+    init(context: PluginContext): void;
+    private registerInlineNodeSpec;
+    private registerCommands;
+    private registerKeymap;
+}
+
 /** Returns true if the mark set contains a mark of the given type. */
 export declare function hasMark(marks: readonly Mark[], markType: MarkTypeName): boolean;
 
@@ -563,12 +805,21 @@ export declare class HeadingPlugin implements Plugin_2 {
     private registerCommands;
     private registerKeymaps;
     private registerInputRules;
+    private registerPickerEntries;
     private registerToolbarItem;
     private updateComboLabel;
     private getActiveLabel;
     private dismissPopup;
     private renderHeadingPopup;
     private createPickerItem;
+    private static readonly HEADING_TYPES;
+    /**
+     * Handles Enter inside a heading block.
+     * Empty heading → convert to paragraph.
+     * Cursor at end → split and convert new block to paragraph.
+     * Cursor in middle → normal split (both stay heading).
+     */
+    private handleEnter;
     /**
      * Toggles between a special block type (title/subtitle) and paragraph.
      * If the block is already that type, resets to paragraph.
@@ -682,6 +933,55 @@ export declare class HorizontalRulePlugin implements Plugin_2 {
     private insertHorizontalRule;
 }
 
+export declare const IMAGE_UPLOAD_SERVICE: ServiceKey<ImageUploadService>;
+
+export declare interface ImageAttrs {
+    readonly src: string;
+    readonly alt: string;
+    readonly width?: number;
+    readonly height?: number;
+    readonly align: 'left' | 'center' | 'right';
+}
+
+export declare class ImagePlugin implements Plugin_2 {
+    readonly id = "image";
+    readonly name = "Image";
+    readonly priority = 45;
+    private readonly config;
+    private readonly uploadStates;
+    private readonly blobUrls;
+    constructor(config?: Partial<ImagePluginConfig>);
+    init(context: PluginContext): void;
+    destroy(): void;
+    onStateChange(_oldState: EditorState, newState: EditorState, _tr: Transaction): void;
+    private registerNodeSpec;
+    private registerNodeView;
+    private registerFileHandler;
+    private handleFileInsert;
+    private uploadFile;
+    private registerToolbarItem;
+    private renderImagePopup;
+    private isAcceptedType;
+}
+
+export declare interface ImagePluginConfig {
+    readonly maxWidth: number;
+    readonly maxFileSize: number;
+    readonly acceptedTypes: readonly string[];
+    readonly resizable: boolean;
+    readonly separatorAfter?: boolean;
+}
+
+export declare interface ImageUploadResult {
+    readonly url: string;
+    readonly width?: number;
+    readonly height?: number;
+}
+
+export declare interface ImageUploadService {
+    upload(file: File): Promise<ImageUploadResult>;
+}
+
 export declare interface InlineDecoration {
     readonly type: 'inline';
     readonly blockId: BlockId;
@@ -735,6 +1035,9 @@ export declare interface InputRule {
     handler(state: EditorState, match: RegExpMatchArray, start: number, end: number): Transaction | null;
 }
 
+/** Inserts a hard line break (InlineNode) at the current cursor position. */
+export declare function insertHardBreakCommand(state: EditorState): Transaction | null;
+
 export declare interface InsertInlineNodeStep {
     readonly type: 'insertInlineNode';
     readonly blockId: BlockId;
@@ -847,6 +1150,9 @@ export declare type Keymap = Readonly<Record<string, KeymapHandler>>;
  */
 export declare type KeymapHandler = () => boolean;
 
+/** Built-in light theme. */
+export declare const LIGHT_THEME: Theme;
+
 export declare interface LinkConfig {
     /** Whether to add rel="noopener noreferrer" and target="_blank" by default. */
     readonly openInNewTab: boolean;
@@ -983,7 +1289,7 @@ export declare function navigateArrowIntoVoid(state: EditorState, direction: 'le
 /** Plugins augment this interface to register typed node attributes. */
 export declare interface NodeAttrRegistry {
     paragraph: {
-        textAlign?: TextAlignment;
+        align?: BlockAlignment;
     };
 }
 
@@ -1035,6 +1341,14 @@ export declare interface NodeSpec<T extends string = string> {
     readonly parseHTML?: readonly ParseRule[];
     /** Tags and attributes this spec needs through DOMPurify sanitization. */
     readonly sanitize?: SanitizeConfig;
+    /**
+     * If provided, the Reconciler groups consecutive blocks with the same
+     * wrapper key into a shared wrapper element. Useful for semantic list
+     * wrappers (`<ul>`, `<ol>`) around `<li>` block elements.
+     */
+    wrapper?(node: Omit<BlockNode, 'attrs'> & {
+        readonly attrs: NodeAttrsFor<T>;
+    }): WrapperSpec;
 }
 
 /** @deprecated Use {@link NodeTypeName} for new code. */
@@ -1081,6 +1395,9 @@ export declare class NotectlEditor extends HTMLElement {
     private readonly readyPromise;
     private initialized;
     private preInitPlugins;
+    private themeStyleSheet;
+    private systemThemeQuery;
+    private systemThemeHandler;
     constructor();
     static get observedAttributes(): string[];
     connectedCallback(): void;
@@ -1134,8 +1451,18 @@ export declare class NotectlEditor extends HTMLElement {
     whenReady(): Promise<void>;
     /** Updates configuration at runtime. */
     configure(config: Partial<NotectlEditorConfig>): void;
+    /** Changes the theme at runtime. */
+    setTheme(theme: ThemePreset | Theme): void;
+    /** Returns the current theme setting. */
+    getTheme(): ThemePreset | Theme;
     /** Cleans up the editor. Awaiting ensures async plugin teardown completes. */
     destroy(): Promise<void>;
+    /** Applies a theme. Called during init() and on runtime changes. */
+    private applyTheme;
+    private setThemeStyleSheet;
+    private setupSystemThemeListener;
+    private cleanupSystemThemeListener;
+    private getSystemTheme;
     /**
      * Processes the declarative `toolbar` config: registers a ToolbarPlugin
      * with layout groups, then registers all plugins from the toolbar groups.
@@ -1149,7 +1476,7 @@ export declare class NotectlEditor extends HTMLElement {
     private emit;
     private onStateChange;
     private updateEmptyState;
-    private announceFormatChange;
+    private announceStateChange;
     private replaceState;
     private serializeBlock;
     private serializeInlineContent;
@@ -1174,6 +1501,8 @@ export declare interface NotectlEditorConfig {
     readonly?: boolean;
     autofocus?: boolean;
     maxHistoryDepth?: number;
+    /** Theme preset or custom Theme object. Defaults to ThemePreset.Light. */
+    theme?: ThemePreset | Theme;
 }
 
 /**
@@ -1187,6 +1516,20 @@ export declare interface ParseRule {
     readonly priority?: number;
 }
 
+/** Partial custom theme — deeply partial for creating overrides. */
+export declare interface PartialTheme {
+    readonly name: string;
+    readonly primitives?: Partial<ThemePrimitives>;
+    readonly toolbar?: Partial<ThemeToolbar>;
+    readonly codeBlock?: Partial<ThemeCodeBlock>;
+    readonly tooltip?: Partial<ThemeTooltip>;
+}
+
+export declare interface PickerEntryStyle {
+    readonly fontSize: string;
+    readonly fontWeight: string;
+}
+
 declare interface Plugin_2<TConfig extends Record<string, unknown> = Record<string, unknown>> {
     readonly id: string;
     readonly name: string;
@@ -1229,7 +1572,10 @@ export declare interface PluginContext {
     registerToolbarItem(item: ToolbarItem): void;
     registerInlineNodeSpec<T extends string>(spec: InlineNodeSpec<T>): void;
     registerFileHandler(pattern: string, handler: FileHandler): void;
+    registerBlockTypePickerEntry(entry: BlockTypePickerEntry): void;
     getSchemaRegistry(): SchemaRegistry;
+    /** Pushes a screen reader announcement via the editor's aria-live region. */
+    announce(text: string): void;
 }
 
 export declare interface PluginEventBus {
@@ -1298,6 +1644,8 @@ export declare interface PluginManagerInitOptions {
     dispatch(transaction: Transaction): void;
     getContainer(): HTMLElement;
     getPluginContainer(position: 'top' | 'bottom'): HTMLElement;
+    /** Pushes a screen reader announcement via the editor's aria-live region. */
+    announce?(text: string): void;
     /** Called after all plugin init() calls complete, before onReady(). */
     onBeforeReady?(): void | Promise<void>;
 }
@@ -1353,6 +1701,9 @@ export declare function resolveParentByPath(doc: Document_2, path: readonly stri
     index: number;
 } | undefined;
 
+/** Resolves a ThemePreset string or Theme object to a full Theme. */
+export declare function resolveTheme(theme: ThemePreset | Theme): Theme;
+
 /**
  * SanitizeConfig: declares which HTML tags and attributes a spec needs
  * to survive DOMPurify sanitization.
@@ -1382,6 +1733,7 @@ export declare class SchemaRegistry {
     private readonly _toolbarItems;
     private readonly _toolbarItemPluginMap;
     private readonly _fileHandlers;
+    private readonly _blockTypePickerEntries;
     registerNodeSpec<T extends string>(spec: NodeSpec<T>): void;
     getNodeSpec(type: string): NodeSpec | undefined;
     removeNodeSpec(type: string): void;
@@ -1412,6 +1764,9 @@ export declare class SchemaRegistry {
     getFileHandlers(): readonly FileHandlerEntry[];
     matchFileHandlers(mimeType: string): FileHandler[];
     removeFileHandler(handler: FileHandler): void;
+    registerBlockTypePickerEntry(entry: BlockTypePickerEntry): void;
+    getBlockTypePickerEntries(): readonly BlockTypePickerEntry[];
+    removeBlockTypePickerEntry(id: string): void;
     /** Returns all NodeSpec parseHTML rules, sorted by priority descending. */
     getBlockParseRules(): readonly {
         readonly rule: ParseRule;
@@ -1578,6 +1933,17 @@ export declare interface SuperSubToolbarConfig {
     readonly subscript?: boolean;
 }
 
+export declare interface SyntaxHighlighter {
+    tokenize(code: string, language: string): readonly SyntaxToken[];
+    getSupportedLanguages(): readonly string[];
+}
+
+export declare interface SyntaxToken {
+    readonly from: number;
+    readonly to: number;
+    readonly type: string;
+}
+
 export declare interface TableConfig {
     /** Maximum rows in grid picker. Defaults to 8. */
     readonly maxPickerRows?: number;
@@ -1627,43 +1993,6 @@ export declare interface TableSelectionService {
 
 export declare const TableSelectionServiceKey: ServiceKey<TableSelectionService>;
 
-export declare type TextAlignment = 'left' | 'center' | 'right' | 'justify';
-
-export declare interface TextAlignmentConfig {
-    /** Which alignments to expose. Defaults to all four. */
-    readonly alignments: readonly TextAlignment[];
-    /** Block types that support alignment. Defaults to paragraph + heading. */
-    readonly alignableTypes: readonly string[];
-    /** When true, a separator is rendered after the toolbar item. */
-    readonly separatorAfter?: boolean;
-}
-
-export declare class TextAlignmentPlugin implements Plugin_2 {
-    readonly id = "text-alignment";
-    readonly name = "Text Alignment";
-    readonly priority = 90;
-    private readonly config;
-    private alignableTypes;
-    constructor(config?: Partial<TextAlignmentConfig>);
-    init(context: PluginContext): void;
-    /**
-     * Patches existing NodeSpecs for alignable block types to support the
-     * `textAlign` attribute and render it as an inline style.
-     */
-    private patchNodeSpecs;
-    private registerCommands;
-    private registerKeymaps;
-    private registerToolbarItem;
-    /**
-     * Preserves the `textAlign` attribute when other plugins change the block
-     * type (e.g. paragraph → heading) via `setBlockType`, which replaces attrs.
-     */
-    private registerMiddleware;
-    private setAlignment;
-    private isNonDefaultAlignment;
-    private isAlignable;
-}
-
 export declare interface TextColorConfig {
     /**
      * Restricts the color picker to a specific set of hex colors.
@@ -1740,6 +2069,69 @@ export declare interface TextSegment {
     readonly marks: readonly Mark[];
 }
 
+/** Full theme definition. */
+export declare interface Theme {
+    readonly name: string;
+    readonly primitives: ThemePrimitives;
+    readonly toolbar?: Partial<ThemeToolbar>;
+    readonly codeBlock?: Partial<ThemeCodeBlock>;
+    readonly tooltip?: Partial<ThemeTooltip>;
+}
+
+/** Component-level code block overrides. */
+export declare interface ThemeCodeBlock {
+    readonly background: string;
+    readonly foreground: string;
+    readonly headerBackground: string;
+    readonly headerForeground: string;
+    readonly headerBorder: string;
+}
+
+/** Built-in theme presets. */
+export declare const ThemePreset: {
+    readonly Light: "light";
+    readonly Dark: "dark";
+    readonly System: "system";
+};
+
+export declare type ThemePreset = (typeof ThemePreset)[keyof typeof ThemePreset];
+
+/**
+ * Theme token types, built-in themes, and theme creation helpers.
+ */
+/** Primitive color palette a theme defines. */
+export declare interface ThemePrimitives {
+    readonly background: string;
+    readonly foreground: string;
+    readonly mutedForeground: string;
+    readonly border: string;
+    readonly borderFocus: string;
+    readonly primary: string;
+    readonly primaryForeground: string;
+    readonly primaryMuted: string;
+    readonly surfaceRaised: string;
+    readonly surfaceOverlay: string;
+    readonly hoverBackground: string;
+    readonly activeBackground: string;
+    readonly danger: string;
+    readonly dangerMuted: string;
+    readonly success: string;
+    readonly shadow: string;
+    readonly focusRing: string;
+}
+
+/** Component-level toolbar overrides. */
+export declare interface ThemeToolbar {
+    readonly background: string;
+    readonly borderColor: string;
+}
+
+/** Component-level tooltip overrides. */
+export declare interface ThemeTooltip {
+    readonly background: string;
+    readonly foreground: string;
+}
+
 export declare function toggleBold(state: EditorState, features?: FeatureConfig): Transaction | null;
 
 export declare function toggleItalic(state: EditorState, features?: FeatureConfig): Transaction | null;
@@ -1811,37 +2203,38 @@ export declare class ToolbarPlugin implements Plugin_2 {
     private context;
     private toolbarElement;
     private buttons;
-    private activePopup;
-    private closePopupHandler;
     private readonly hiddenItems;
-    private tooltipElement;
-    private tooltipTimer;
     private readonly layoutConfig;
+    private focusedIndex;
+    private tooltip;
+    private popupController;
     constructor(layoutConfig?: ToolbarLayoutConfig);
     init(context: PluginContext): void;
     onReady(): void;
     destroy(): void;
     onStateChange(_oldState: EditorState, newState: EditorState, _tr: Transaction): void;
     onConfigure(config: PluginConfig): void;
-    private createTooltipElement;
-    private showTooltip;
-    private hideTooltip;
     private createToolbarElement;
     private renderItems;
+    private initRovingTabindex;
+    private setRovingFocus;
+    /** Returns the active element, respecting shadow DOM boundaries. */
+    private getActiveElement;
+    private syncFocusedIndex;
+    private handleToolbarKeydown;
+    /** Activates a toolbar button (shared between mouse click and keyboard). */
+    private activateButton;
     private renderItemsByLayout;
     private renderItemsByPriority;
     private createButton;
-    private activePopupButton;
-    private togglePopup;
-    private closePopup;
-    private renderGridPicker;
-    private renderDropdown;
     private updateButtonStates;
 }
 
 export declare interface ToolbarServiceAPI {
     /** Re-reads isActive/isEnabled from state and updates all buttons. */
     refresh(): void;
+    /** Closes the currently open popup, if any. */
+    closePopup(): void;
 }
 
 export declare const ToolbarServiceKey: ServiceKey<ToolbarServiceAPI>;
@@ -1914,6 +2307,7 @@ export declare class TransactionBuilder {
 export declare interface TransactionMetadata {
     readonly origin: TransactionOrigin;
     readonly timestamp: number;
+    readonly historyDirection?: 'undo' | 'redo';
 }
 
 export declare type TransactionMiddleware = (tr: Transaction, state: EditorState, next: MiddlewareNext) => void;
@@ -1951,4 +2345,16 @@ export declare function widgetDecoration(blockId: BlockId, offset: number, toDOM
     readonly key?: string;
 }): WidgetDecoration;
 
+/** Describes a wrapper element that groups consecutive blocks of the same kind. */
+export declare interface WrapperSpec {
+    /** The HTML tag for the wrapper element (e.g., 'ul', 'ol'). */
+    readonly tag: string;
+    /** A key to group consecutive blocks. Blocks with the same key share a wrapper. */
+    readonly key: string;
+    /** Optional CSS class for the wrapper element. */
+    readonly className?: string;
+    /** Optional attributes for the wrapper element. */
+    readonly attrs?: Readonly<Record<string, string>>;
+}
+
 export { }