@blokhaus/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,834 @@
+import * as react from 'react';
+import { ReactElement } from 'react';
+export { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import * as lexical from 'lexical';
+import { TextNode, LexicalEditor, LexicalNode, NodeKey, DecoratorNode, EditorConfig, DOMExportOutput, DOMConversionMap, Spread, SerializedLexicalNode, ElementNode, ElementDOMSlot, SerializedElementNode, RangeSelection } from 'lexical';
+export { $getSelection, $isRangeSelection, LexicalEditor, TextNode } from 'lexical';
+
+interface EditorRootProps {
+    /** Unique namespace — required for multi-editor isolation. See Section 8. */
+    namespace: string;
+    /** Initial serialized Lexical JSON state. Pass null for a blank editor. */
+    initialState?: string | null;
+    children?: React.ReactNode;
+    className?: string;
+    /** Document-level text direction. Omit for per-paragraph auto-detection (default). */
+    dir?: "ltr" | "rtl" | "auto";
+    /** Customizable placeholder text. Default: "Start writing..." */
+    placeholder?: string;
+    /** Read-only mode. Default: true (editable). */
+    editable?: boolean;
+    /** Whether the editor auto-focuses on mount. Default: true. */
+    autoFocus?: boolean;
+    /** Custom error handler for Lexical errors. Default: console.error + throw. */
+    onError?: (error: Error) => void;
+}
+declare function EditorRoot({ namespace, initialState, children, className, dir, placeholder, editable, autoFocus, onError, }: EditorRootProps): react.JSX.Element;
+
+/**
+ * Color palette types and default palette for text color & background highlighting.
+ *
+ * Colors are stored as CSS variable references (e.g., "var(--blokhaus-text-red)")
+ * so developers can override them via tokens.css to rebrand.
+ */
+interface ColorEntry {
+    /** Human-readable label shown in the picker */
+    label: string;
+    /** CSS value to apply — should be a var() reference */
+    value: string;
+    /** Preview swatch color (raw hex/hsl for rendering the dot in the picker) */
+    swatch: string;
+}
+interface ColorPalette {
+    text: ColorEntry[];
+    highlight: ColorEntry[];
+}
+declare const DEFAULT_COLOR_PALETTE: ColorPalette;
+
+/**
+ * Font family entries for the FontPicker dropdown.
+ *
+ * Values use CSS variable references so apps can swap the actual
+ * Google Font (or any other font) without touching the library.
+ */
+interface FontFamilyEntry {
+    /** Human-readable label shown in the picker */
+    label: string;
+    /** CSS font-family value to apply. Empty string = remove / default. */
+    value: string;
+    /** Font stack used to render the preview text in the picker dropdown */
+    preview: string;
+}
+declare const DEFAULT_FONT_FAMILIES: FontFamilyEntry[];
+
+interface FloatingToolbarProps {
+    colorPalette?: ColorPalette;
+    fontFamilies?: FontFamilyEntry[];
+}
+declare function FloatingToolbar({ colorPalette, fontFamilies }?: FloatingToolbarProps): react.ReactPortal | null;
+
+interface SlashMenuItem {
+    id: string;
+    label: string;
+    description: string;
+    icon: React.ComponentType<{
+        size?: number;
+    }>;
+    onSelect: () => void;
+    /** Extra search terms (e.g. "h1" for "Heading 1") */
+    keywords?: string[];
+}
+interface SlashMenuProps {
+    items?: SlashMenuItem[];
+}
+declare function SlashMenu({ items: externalItems }: SlashMenuProps): react.ReactPortal | null;
+
+interface OverlayPortalProps {
+    namespace: string;
+}
+declare function OverlayPortal({ namespace }: OverlayPortalProps): react.JSX.Element | null;
+
+interface EmojiItem {
+    emoji: string;
+    name: string;
+    keywords: string[];
+}
+declare const DEFAULT_EMOJIS: EmojiItem[];
+
+interface EmojiPickerPluginProps {
+    /** Override the built-in emoji list. */
+    emojis?: EmojiItem[];
+    /** Max results shown in dropdown (default: 8). */
+    maxResults?: number;
+    /** Custom render function for each emoji row. */
+    renderItem?: (item: EmojiItem, isSelected: boolean) => React.ReactNode;
+    /** Custom render function for the dropdown container. */
+    renderDropdown?: (props: {
+        children: React.ReactNode;
+        position: {
+            top: number;
+            left: number;
+        };
+    }) => React.ReactNode;
+}
+declare function EmojiPickerPlugin({ emojis, maxResults, renderItem, renderDropdown, }?: EmojiPickerPluginProps): react.ReactPortal | null;
+
+interface LinkInputRenderProps {
+    initialUrl: string;
+    onSubmit: (url: string) => void;
+    onRemove: () => void;
+    onClose: () => void;
+    position: {
+        top: number;
+        left: number;
+    };
+}
+interface LinkPreviewRenderProps {
+    url: string;
+    onEdit: () => void;
+    onRemove: () => void;
+    onClose: () => void;
+    position: {
+        top: number;
+        left: number;
+    };
+}
+interface LinkPluginConfig {
+    /** Custom render for the link input popover. */
+    renderLinkInput?: (props: LinkInputRenderProps) => React.ReactNode;
+    /** Custom render for the link preview popover. */
+    renderLinkPreview?: (props: LinkPreviewRenderProps) => React.ReactNode;
+    /** Validate URL before applying (default: basic URL validation). */
+    validateUrl?: (url: string) => boolean;
+    /** Link target behavior (default: "_blank"). */
+    target?: string;
+    /** Link rel attribute (default: "noopener noreferrer"). */
+    rel?: string;
+}
+declare function LinkPlugin({ config }?: {
+    config?: LinkPluginConfig;
+}): react.JSX.Element | null;
+
+type UploadHandler = (file: File) => Promise<string>;
+/** Model-level configuration passed to the provider's generate() call. */
+interface AIGenerateConfig {
+    /** Sampling temperature (0–2). Lower = more deterministic. Provider-specific. */
+    temperature?: number;
+    /** Maximum tokens to generate. Provider-specific. */
+    maxTokens?: number;
+    /** System prompt / persona for the model. */
+    systemPrompt?: string;
+}
+/** Parameters passed to AIProvider.generate(). */
+interface AIGenerateParams {
+    /** The user's prompt text. */
+    prompt: string;
+    /** Surrounding editor content serialized as Markdown. */
+    context: string;
+    /** Optional model-level configuration. */
+    config?: AIGenerateConfig;
+}
+interface AIProvider {
+    /** Human-readable name (e.g., "Mistral", "Ollama") */
+    name: string;
+    /**
+     * Called with a prompt, surrounding editor context, and optional model config.
+     * Must return a ReadableStream of text chunks.
+     * The library consumes this stream — it does not care about the underlying provider.
+     */
+    generate: (params: AIGenerateParams) => Promise<ReadableStream<string>>;
+}
+/** Labels for the AIPreviewNode buttons and header. All optional with sensible defaults. */
+interface AIPreviewLabels {
+    /** Header label (default: "AI") */
+    header?: string;
+    /** Streaming status text (default: "generating...") */
+    streaming?: string;
+    /** Accept button label (default: "Accept") */
+    accept?: string;
+    /** Discard button label (default: "Discard") */
+    discard?: string;
+    /** Retry button label (default: "Retry") */
+    retry?: string;
+    /** Dismiss button label for error state (default: "Dismiss") */
+    dismiss?: string;
+    /** Default error message when no specific message is available (default: "An error occurred") */
+    defaultError?: string;
+}
+/** Retry configuration for the AIPreviewNode. */
+interface AIRetryConfig {
+    /** Maximum number of retries allowed. Set to 0 to disable retry. Default: Infinity */
+    maxRetries?: number;
+}
+/** Props for a custom AI prompt input component. */
+interface AIPromptInputRenderProps {
+    /** Current position for fixed positioning */
+    position: {
+        top: number;
+        left: number;
+    };
+    /** Call with the prompt text to submit */
+    onSubmit: (prompt: string) => void;
+    /** Call to close/cancel the prompt */
+    onClose: () => void;
+}
+/**
+ * Full configuration for the AI integration.
+ * Pass to AIPlugin to customize every aspect of the AI experience.
+ */
+interface AIPluginConfig {
+    /** Model-level configuration (temperature, maxTokens, systemPrompt) */
+    generate?: AIGenerateConfig;
+    /** Custom labels for the preview node UI */
+    labels?: AIPreviewLabels;
+    /** Retry configuration */
+    retry?: AIRetryConfig;
+    /** Number of preceding blocks to include as context. Default: 3 */
+    contextWindowSize?: number;
+    /** Called when the AI stream encounters an error. Useful for logging/telemetry. */
+    onError?: (error: Error) => void;
+    /** Called when the user accepts generated content. Useful for analytics. */
+    onAccept?: (content: string) => void;
+    /** Called when the user discards generated content. */
+    onDiscard?: () => void;
+    /**
+     * Custom prompt input component. When provided, replaces the built-in prompt input.
+     * Receives position, onSubmit, and onClose as props.
+     */
+    renderPrompt?: (props: AIPromptInputRenderProps) => React.ReactElement;
+}
+interface InputRule {
+    /** The trigger pattern. Must include a trailing space or newline to fire. */
+    pattern: RegExp;
+    /** The node type this rule produces. */
+    type: 'heading' | 'quote' | 'code' | 'divider' | 'custom';
+    /**
+     * Called when the pattern matches. Receives the matched text and the
+     * current TextNode. Must perform its mutation inside an editor.update() call.
+     * The engine handles deleting the trigger text before calling this.
+     */
+    onMatch: (match: RegExpMatchArray, node: TextNode, editor: LexicalEditor) => void;
+}
+
+interface MentionItem {
+    id: string;
+    label: string;
+    /** Optional: rendered inside the dropdown item */
+    meta?: string;
+    /** Optional: URL to an avatar or icon */
+    icon?: string;
+}
+interface MentionProvider {
+    /** The character that triggers this provider (e.g., '@', '#') */
+    trigger: string;
+    /**
+     * Called when the user types after the trigger. Return a promise that
+     * resolves to matching items. Return an empty array for no results.
+     */
+    onSearch: (query: string) => Promise<MentionItem[]>;
+    /**
+     * Renders a single item in the Radix dropdown.
+     * Keep it lightweight — this renders on every keystroke.
+     */
+    renderItem: (item: MentionItem) => React.ReactNode;
+    /**
+     * Called when the user selects an item. Return the Lexical node to insert.
+     * The engine handles replacing the trigger + query text with this node.
+     */
+    onSelect: (item: MentionItem) => LexicalNode;
+}
+
+interface InputRulePluginProps {
+    rules?: InputRule[];
+}
+declare function InputRulePlugin({ rules }: InputRulePluginProps): null;
+
+interface ImagePluginProps {
+    uploadHandler: UploadHandler;
+    /** Maximum file size in bytes. Default: 10MB. */
+    maxFileSize?: number;
+    /** Allowed MIME types. Default: jpeg, png, gif, webp, svg+xml. */
+    allowedFormats?: string[];
+    /** Called when a file is rejected (too large or wrong format). */
+    onFileRejected?: (file: File, reason: "size" | "format") => void;
+    /** Called when an upload fails. */
+    onUploadError?: (file: File, error: unknown) => void;
+}
+declare function ImagePlugin({ uploadHandler, maxFileSize, allowedFormats, onFileRejected, onUploadError, }: ImagePluginProps): null;
+
+interface AIPluginProps {
+    /** The AI provider that supplies streaming text generation. */
+    provider: AIProvider;
+    /**
+     * Optional configuration for the AI integration.
+     * Controls model parameters, UI labels, retry behaviour, context window,
+     * error handling, analytics callbacks, and custom prompt input rendering.
+     */
+    config?: AIPluginConfig;
+}
+declare function AIPlugin({ provider, config }: AIPluginProps): react.JSX.Element | null;
+
+interface MentionPluginProps {
+    /** One or more mention providers, each with their own trigger character. */
+    providers: MentionProvider[];
+}
+declare function MentionPlugin({ providers }: MentionPluginProps): react.ReactPortal | null;
+
+/**
+ * PastePlugin — intercepts paste events, sanitises incoming HTML,
+ * and inserts clean Lexical nodes into the AST.
+ *
+ * See CLAUDE.md Section 13 for the full specification.
+ */
+declare function PastePlugin(): null;
+
+interface UseEditorStateOptions {
+    /**
+     * Debounce delay in milliseconds. Do not set below 200ms.
+     * High-frequency editor.update() calls on every keystroke will
+     * degrade performance on large documents.
+     */
+    debounceMs?: number;
+    onChange?: (serializedState: string) => void;
+}
+declare function useEditorState({ debounceMs, onChange, }?: UseEditorStateOptions): {
+    serializedState: string;
+};
+
+interface WordCountResult {
+    words: number;
+    characters: number;
+}
+declare function useWordCount(debounceMs?: number): WordCountResult;
+
+/**
+ * MobileToolbar — bottom-anchored formatting toolbar for touch devices.
+ *
+ * Renders a fixed toolbar at the bottom of the viewport when the user
+ * has selected text inside the editor. Completely hidden on non-touch devices.
+ *
+ * See CLAUDE.md Section 14 for the specification.
+ */
+declare function MobileToolbar(): react.ReactPortal | null;
+
+/**
+ * Paste sanitisation pipeline.
+ *
+ * Takes a raw HTML string (typically from clipboard) and returns clean,
+ * semantic HTML safe for conversion into Lexical nodes.
+ *
+ * See CLAUDE.md Section 13.2 for the full specification.
+ */
+/**
+ * Sanitises pasted HTML for safe insertion into the Lexical AST.
+ *
+ * This is a pure function: it takes an HTML string and returns a sanitised
+ * HTML string. It uses `DOMParser` (browser API) to parse and manipulate
+ * the HTML.
+ *
+ * @param html - Raw HTML string from the clipboard
+ * @returns Sanitised HTML string safe for `$generateNodesFromDOM`
+ */
+declare function sanitizePastedHTML(html: string): string;
+
+declare function ColorPlugin(): null;
+
+interface ColorPickerProps {
+    palette?: ColorPalette;
+    activeTextColor: string | null;
+    activeHighlightColor: string | null;
+    onClose: () => void;
+}
+declare function ColorPicker({ palette, activeTextColor, activeHighlightColor, onClose, }: ColorPickerProps): react.JSX.Element;
+
+/**
+ * Registers @lexical/list behaviour: Enter on an empty list item exits the list,
+ * Tab/Shift-Tab for indent/outdent, and other list integrity transforms.
+ * Also registers check list behaviour: click/spacebar to toggle checkbox state.
+ */
+declare function ListPlugin(): null;
+
+interface TablePluginProps {
+    hasCellMerge?: boolean;
+    hasCellBackgroundColor?: boolean;
+    hasTabHandler?: boolean;
+}
+declare function TablePlugin({ hasCellMerge, hasTabHandler, }: TablePluginProps): null;
+
+declare function TableActionMenu(): react.ReactPortal | null;
+
+declare function TableHoverActions(): react.ReactPortal | null;
+
+declare const OPEN_SLASH_MENU_COMMAND: lexical.LexicalCommand<void>;
+declare const INSERT_IMAGE_COMMAND: lexical.LexicalCommand<File>;
+declare const OPEN_AI_PROMPT_COMMAND: lexical.LexicalCommand<void>;
+declare const INSERT_AI_PREVIEW_COMMAND: lexical.LexicalCommand<{
+    prompt: string;
+}>;
+declare const OPEN_EMOJI_PICKER_COMMAND: lexical.LexicalCommand<void>;
+declare const OPEN_LINK_INPUT_COMMAND: lexical.LexicalCommand<void>;
+declare const SET_TEXT_COLOR_COMMAND: lexical.LexicalCommand<string>;
+declare const SET_HIGHLIGHT_COLOR_COMMAND: lexical.LexicalCommand<string>;
+declare const INSERT_TABLE_COMMAND_BLOKHAUS: lexical.LexicalCommand<{
+    rows: number;
+    columns: number;
+}>;
+declare const INSERT_CALLOUT_COMMAND: lexical.LexicalCommand<{
+    emoji?: string;
+    colorPreset?: string;
+}>;
+declare const INSERT_VIDEO_COMMAND: lexical.LexicalCommand<{
+    file: File;
+} | {
+    url: string;
+}>;
+declare const OPEN_VIDEO_INPUT_COMMAND: lexical.LexicalCommand<void>;
+declare const INSERT_TOGGLE_COMMAND: lexical.LexicalCommand<{
+    isOpen?: boolean;
+} | undefined>;
+declare const SET_FONT_FAMILY_COMMAND: lexical.LexicalCommand<string>;
+declare const SET_BLOCK_DIRECTION_COMMAND: lexical.LexicalCommand<"ltr" | "rtl">;
+
+declare const DirectionPlugin: () => null;
+
+interface FontPickerProps {
+    fonts?: FontFamilyEntry[];
+    activeFont: string | null;
+    onClose: () => void;
+}
+declare function FontPicker({ fonts, activeFont, onClose, }: FontPickerProps): react.JSX.Element;
+
+interface ImagePayload {
+    src: string;
+    altText: string;
+    width?: number;
+    height?: number;
+    key?: NodeKey;
+}
+type SerializedImageNode = Spread<{
+    src: string;
+    altText: string;
+    width?: number;
+    height?: number;
+}, SerializedLexicalNode>;
+declare class ImageNode extends DecoratorNode<ReactElement> {
+    __src: string;
+    __altText: string;
+    __width: number | undefined;
+    __height: number | undefined;
+    static getType(): string;
+    static clone(node: ImageNode): ImageNode;
+    constructor(src: string, altText: string, width?: number, height?: number, key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedImageNode): ImageNode;
+    exportJSON(): SerializedImageNode;
+    getSrc(): string;
+    getAltText(): string;
+    decorate(): ReactElement;
+}
+declare function $createImageNode(payload: ImagePayload): ImageNode;
+declare function $isImageNode(node: LexicalNode | null | undefined): node is ImageNode;
+
+type SerializedLoadingImageNode = Spread<{
+    objectURL: string;
+}, SerializedLexicalNode>;
+declare class LoadingImageNode extends DecoratorNode<ReactElement> {
+    __objectURL: string;
+    static getType(): string;
+    static clone(node: LoadingImageNode): LoadingImageNode;
+    constructor(objectURL: string, key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedLoadingImageNode): LoadingImageNode;
+    exportJSON(): SerializedLoadingImageNode;
+    getObjectURL(): string;
+    decorate(): ReactElement;
+}
+declare function $createLoadingImageNode(objectURL: string): LoadingImageNode;
+declare function $isLoadingImageNode(node: LexicalNode | null | undefined): node is LoadingImageNode;
+
+interface AIPreviewPayload {
+    prompt: string;
+    context: string;
+    key?: NodeKey;
+}
+type SerializedAIPreviewNode = Spread<{
+    prompt: string;
+    context: string;
+}, SerializedLexicalNode>;
+declare class AIPreviewNode extends DecoratorNode<ReactElement> {
+    __prompt: string;
+    __context: string;
+    static getType(): string;
+    static clone(node: AIPreviewNode): AIPreviewNode;
+    constructor(prompt: string, context: string, key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serialized: SerializedAIPreviewNode): AIPreviewNode;
+    exportJSON(): SerializedAIPreviewNode;
+    decorate(): ReactElement;
+}
+declare function $createAIPreviewNode(payload: AIPreviewPayload): AIPreviewNode;
+declare function $isAIPreviewNode(node: LexicalNode | null | undefined): node is AIPreviewNode;
+
+interface MentionPayload {
+    id: string;
+    label: string;
+    trigger: string;
+    key?: NodeKey;
+}
+type SerializedMentionNode = Spread<{
+    mentionId: string;
+    label: string;
+    trigger: string;
+}, SerializedLexicalNode>;
+declare class MentionNode extends DecoratorNode<ReactElement> {
+    __mentionId: string;
+    __label: string;
+    __trigger: string;
+    static getType(): string;
+    static clone(node: MentionNode): MentionNode;
+    constructor(mentionId: string, label: string, trigger: string, key?: NodeKey);
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serialized: SerializedMentionNode): MentionNode;
+    exportJSON(): SerializedMentionNode;
+    isInline(): true;
+    getTextContent(): string;
+    decorate(): ReactElement;
+}
+declare function $createMentionNode(payload: MentionPayload): MentionNode;
+declare function $isMentionNode(node: LexicalNode | null | undefined): node is MentionNode;
+
+interface CodeBlockPayload {
+    code: string;
+    language: string;
+    key?: NodeKey;
+    autoFocus?: boolean;
+}
+type SerializedCodeBlockNode = Spread<{
+    code: string;
+    language: string;
+}, SerializedLexicalNode>;
+declare class CodeBlockNode extends DecoratorNode<ReactElement> {
+    __code: string;
+    __language: string;
+    __autoFocus: boolean;
+    static getType(): string;
+    static clone(node: CodeBlockNode): CodeBlockNode;
+    constructor(code: string, language: string, key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serialized: SerializedCodeBlockNode): CodeBlockNode;
+    exportJSON(): SerializedCodeBlockNode;
+    getCode(): string;
+    getLanguage(): string;
+    decorate(): ReactElement;
+}
+declare function $createCodeBlockNode(payload: CodeBlockPayload): CodeBlockNode;
+declare function $isCodeBlockNode(node: LexicalNode | null | undefined): node is CodeBlockNode;
+
+interface CalloutPayload {
+    emoji?: string;
+    colorPreset?: string;
+    key?: NodeKey;
+}
+type SerializedCalloutNode = Spread<{
+    emoji: string;
+    colorPreset: string;
+}, SerializedElementNode>;
+declare class CalloutNode extends ElementNode {
+    __emoji: string;
+    __colorPreset: string;
+    static getType(): string;
+    static clone(node: CalloutNode): CalloutNode;
+    constructor(emoji?: string, colorPreset?: string, key?: NodeKey);
+    createDOM(config: EditorConfig): HTMLElement;
+    /**
+     * Tell Lexical's reconciler to insert children after the emoji span.
+     * This is the correct API (Lexical 0.40+) for nodes whose createDOM()
+     * includes accessory elements that aren't Lexical children.
+     */
+    getDOMSlot(element: HTMLElement): ElementDOMSlot;
+    updateDOM(prevNode: CalloutNode, dom: HTMLElement): boolean;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serialized: SerializedCalloutNode): CalloutNode;
+    exportJSON(): SerializedCalloutNode;
+    getEmoji(): string;
+    setEmoji(emoji: string): this;
+    getColorPreset(): string;
+    setColorPreset(preset: string): this;
+}
+declare function $createCalloutNode(payload?: CalloutPayload): CalloutNode;
+declare function $isCalloutNode(node: LexicalNode | null | undefined): node is CalloutNode;
+
+/**
+ * Callout color preset definitions.
+ *
+ * Each preset maps to CSS variables defined in tokens.css:
+ *   --blokhaus-callout-{id}-bg   (background)
+ *   --blokhaus-callout-{id}-border (left border accent)
+ *
+ * Developers can override presets via the `presets` prop on `<CalloutPlugin>`.
+ */
+interface CalloutPreset {
+    /** Unique identifier used in CSS class names and serialization */
+    id: string;
+    /** Human-readable label shown in UI */
+    label: string;
+    /** Default emoji for this preset */
+    emoji: string;
+    /** Raw background color for rendering the picker dot */
+    bgSwatch: string;
+    /** Raw border color for rendering the picker dot */
+    borderSwatch: string;
+}
+declare const DEFAULT_CALLOUT_PRESETS: CalloutPreset[];
+
+interface CalloutPluginProps {
+    /** Override the default color presets */
+    presets?: CalloutPreset[];
+    /** Default emoji for newly created callouts */
+    defaultEmoji?: string;
+    /** Default color preset for newly created callouts */
+    defaultPreset?: string;
+}
+declare function CalloutPlugin({ presets, defaultEmoji, defaultPreset, }?: CalloutPluginProps): react.ReactPortal | null;
+
+/**
+ * Serializes an array of Lexical nodes to Markdown.
+ * Pure function — call inside editor.read().
+ */
+declare function serializeNodesToMarkdown(nodes: LexicalNode[]): string;
+/**
+ * Parses a Markdown string into Lexical nodes.
+ * Must be called inside editor.update() — creates Lexical nodes that require
+ * an active editor context.
+ */
+declare function $parseMarkdownToLexicalNodes(markdown: string): LexicalNode[];
+
+interface VideoEmbedRenderProps {
+    src: string;
+    provider: string;
+    title: string;
+}
+interface VideoFileRenderProps {
+    src: string;
+    title: string;
+}
+interface VideoPluginProps {
+    /** Handler for uploading video files. Same interface as ImagePlugin. Omit to disable file uploads. */
+    uploadHandler?: UploadHandler;
+    /** Maximum file size in bytes. Default: 50MB. */
+    maxFileSize?: number;
+    /** Allowed MIME types for upload. Default: mp4, webm, quicktime. */
+    allowedFormats?: string[];
+    /** Called when a file is rejected (too large or wrong format). */
+    onFileRejected?: (file: File, reason: "size" | "format") => void;
+}
+declare function VideoPlugin({ uploadHandler, maxFileSize, allowedFormats, onFileRejected, }?: VideoPluginProps): react.JSX.Element | null;
+
+interface VideoPayload {
+    src: string;
+    videoType: "embed" | "file";
+    provider: string;
+    title?: string;
+    key?: NodeKey;
+}
+type SerializedVideoNode = Spread<{
+    src: string;
+    videoType: "embed" | "file";
+    provider: string;
+    title: string;
+}, SerializedLexicalNode>;
+declare class VideoNode extends DecoratorNode<ReactElement> {
+    __src: string;
+    __videoType: "embed" | "file";
+    __provider: string;
+    __title: string;
+    static getType(): string;
+    static clone(node: VideoNode): VideoNode;
+    constructor(src: string, videoType: "embed" | "file", provider: string, title?: string, key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedVideoNode): VideoNode;
+    exportJSON(): SerializedVideoNode;
+    getSrc(): string;
+    getVideoType(): "embed" | "file";
+    getProvider(): string;
+    getTitle(): string;
+    decorate(): ReactElement;
+}
+declare function $createVideoNode(payload: VideoPayload): VideoNode;
+declare function $isVideoNode(node: LexicalNode | null | undefined): node is VideoNode;
+
+declare class HorizontalRuleNode extends DecoratorNode<ReactElement> {
+    static getType(): string;
+    static clone(node: HorizontalRuleNode): HorizontalRuleNode;
+    constructor(key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(_serializedNode: SerializedLexicalNode): HorizontalRuleNode;
+    exportJSON(): SerializedLexicalNode;
+    decorate(): ReactElement;
+}
+declare function $createHorizontalRuleNode(): HorizontalRuleNode;
+declare function $isHorizontalRuleNode(node: LexicalNode | null | undefined): node is HorizontalRuleNode;
+
+type SerializedLoadingVideoNode = Spread<{
+    objectURL: string;
+    fileName: string;
+}, SerializedLexicalNode>;
+declare class LoadingVideoNode extends DecoratorNode<ReactElement> {
+    __objectURL: string;
+    __fileName: string;
+    static getType(): string;
+    static clone(node: LoadingVideoNode): LoadingVideoNode;
+    constructor(objectURL: string, fileName: string, key?: NodeKey);
+    createDOM(_config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedLoadingVideoNode): LoadingVideoNode;
+    exportJSON(): SerializedLoadingVideoNode;
+    getObjectURL(): string;
+    getFileName(): string;
+    decorate(): ReactElement;
+}
+declare function $createLoadingVideoNode(objectURL: string, fileName: string): LoadingVideoNode;
+declare function $isLoadingVideoNode(node: LexicalNode | null | undefined): node is LoadingVideoNode;
+
+/**
+ * Video embed URL parser.
+ * Extracts provider-specific embed URLs from user-pasted video links.
+ * Pure function — no React, no side effects.
+ */
+interface VideoEmbedInfo {
+    provider: "youtube" | "vimeo" | "loom" | "generic";
+    embedUrl: string;
+    /** Thumbnail URL when available (YouTube, Vimeo). */
+    thumbnailUrl?: string;
+}
+/**
+ * Parse a URL string and return embed info for known video providers.
+ * Returns `null` for non-URL strings. Returns `{ provider: "generic" }` for
+ * unrecognized but valid URLs, so any iframe-compatible link works.
+ */
+declare function parseVideoEmbed(url: string): VideoEmbedInfo | null;
+
+interface ToggleContainerPayload {
+    open?: boolean;
+    key?: NodeKey;
+}
+type SerializedToggleContainerNode = Spread<{
+    open: boolean;
+}, SerializedElementNode>;
+declare class ToggleContainerNode extends ElementNode {
+    __open: boolean;
+    static getType(): string;
+    static clone(node: ToggleContainerNode): ToggleContainerNode;
+    constructor(open?: boolean, key?: NodeKey);
+    isShadowRoot(): boolean;
+    createDOM(config: EditorConfig, editor: LexicalEditor): HTMLElement;
+    updateDOM(prevNode: ToggleContainerNode, dom: HTMLElement): boolean;
+    collapseAtStart(_selection: RangeSelection): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    static importJSON(serialized: SerializedToggleContainerNode): ToggleContainerNode;
+    exportJSON(): SerializedToggleContainerNode;
+    getOpen(): boolean;
+    setOpen(open: boolean): void;
+    toggleOpen(): void;
+}
+declare function $createToggleContainerNode(payload?: ToggleContainerPayload): ToggleContainerNode;
+declare function $isToggleContainerNode(node: LexicalNode | null | undefined): node is ToggleContainerNode;
+
+declare class ToggleTitleNode extends ElementNode {
+    static getType(): string;
+    static clone(node: ToggleTitleNode): ToggleTitleNode;
+    createDOM(config: EditorConfig, editor: LexicalEditor): HTMLElement;
+    updateDOM(): boolean;
+    insertNewAfter(_selection: RangeSelection, restoreSelection?: boolean): ElementNode | null;
+    collapseAtStart(_selection: RangeSelection): boolean;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(_serialized: SerializedElementNode): ToggleTitleNode;
+    exportJSON(): SerializedElementNode;
+}
+declare function $createToggleTitleNode(): ToggleTitleNode;
+declare function $isToggleTitleNode(node: LexicalNode | null | undefined): node is ToggleTitleNode;
+
+declare class ToggleContentNode extends ElementNode {
+    static getType(): string;
+    static clone(node: ToggleContentNode): ToggleContentNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    isShadowRoot(): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    static importJSON(_serialized: SerializedElementNode): ToggleContentNode;
+    exportJSON(): SerializedElementNode;
+}
+declare function $createToggleContentNode(): ToggleContentNode;
+declare function $isToggleContentNode(node: LexicalNode | null | undefined): node is ToggleContentNode;
+
+declare function TogglePlugin(): null;
+
+declare function BlockSelectionPlugin(): react.ReactPortal | null;
+
+export { $createAIPreviewNode, $createCalloutNode, $createCodeBlockNode, $createHorizontalRuleNode, $createImageNode, $createLoadingImageNode, $createLoadingVideoNode, $createMentionNode, $createToggleContainerNode, $createToggleContentNode, $createToggleTitleNode, $createVideoNode, $isAIPreviewNode, $isCalloutNode, $isCodeBlockNode, $isHorizontalRuleNode, $isImageNode, $isLoadingImageNode, $isLoadingVideoNode, $isMentionNode, $isToggleContainerNode, $isToggleContentNode, $isToggleTitleNode, $isVideoNode, $parseMarkdownToLexicalNodes, type AIGenerateConfig, type AIGenerateParams, AIPlugin, type AIPluginConfig, type AIPreviewLabels, AIPreviewNode, type AIPreviewPayload, type AIPromptInputRenderProps, type AIProvider, type AIRetryConfig, BlockSelectionPlugin, CalloutNode, type CalloutPayload, CalloutPlugin, type CalloutPreset, CodeBlockNode, type CodeBlockPayload, type ColorEntry, type ColorPalette, ColorPicker, ColorPlugin, DEFAULT_CALLOUT_PRESETS, DEFAULT_COLOR_PALETTE, DEFAULT_EMOJIS, DEFAULT_FONT_FAMILIES, DirectionPlugin, EditorRoot, type EmojiItem, EmojiPickerPlugin, type EmojiPickerPluginProps, FloatingToolbar, type FontFamilyEntry, FontPicker, HorizontalRuleNode, INSERT_AI_PREVIEW_COMMAND, INSERT_CALLOUT_COMMAND, INSERT_IMAGE_COMMAND, INSERT_TABLE_COMMAND_BLOKHAUS, INSERT_TOGGLE_COMMAND, INSERT_VIDEO_COMMAND, ImageNode, type ImagePayload, ImagePlugin, type InputRule, InputRulePlugin, type LinkInputRenderProps, LinkPlugin, type LinkPluginConfig, type LinkPreviewRenderProps, ListPlugin, LoadingImageNode, LoadingVideoNode, type MentionItem, MentionNode, type MentionPayload, MentionPlugin, type MentionProvider, MobileToolbar, OPEN_AI_PROMPT_COMMAND, OPEN_EMOJI_PICKER_COMMAND, OPEN_LINK_INPUT_COMMAND, OPEN_SLASH_MENU_COMMAND, OPEN_VIDEO_INPUT_COMMAND, OverlayPortal, PastePlugin, SET_BLOCK_DIRECTION_COMMAND, SET_FONT_FAMILY_COMMAND, SET_HIGHLIGHT_COLOR_COMMAND, SET_TEXT_COLOR_COMMAND, SlashMenu, type SlashMenuItem, TableActionMenu, TableHoverActions, TablePlugin, ToggleContainerNode, type ToggleContainerPayload, ToggleContentNode, TogglePlugin, ToggleTitleNode, type UploadHandler, type VideoEmbedInfo, type VideoEmbedRenderProps, type VideoFileRenderProps, VideoNode, type VideoPayload, VideoPlugin, parseVideoEmbed, sanitizePastedHTML, serializeNodesToMarkdown, useEditorState, useWordCount };