@railway/inkwell 0.1.0 → 1.0.0

package/dist/index.d.ts

@@ -1,375 +1,478 @@
-import { ReactNode, JSX, RefObject, KeyboardEvent } from 'react';
+import * as react from 'react';
+import { ReactNode, JSX, CSSProperties, RefObject, KeyboardEvent } from 'react';
 import { Plugin } from 'unified';
-import { Awareness } from 'y-protocols/awareness';
-import { XmlText } from 'yjs';
-import { BaseEditor, BaseElement, BaseText } from 'slate';
-import { HistoryEditor } from 'slate-history';
-import { ReactEditor } from 'slate-react';
 
-type RehypePlugin$1 = Plugin<any[], any>;
-type RehypePluginConfig$1 = RehypePlugin$1 | [RehypePlugin$1, Record<string, unknown>];
-/**
- * Props for the InkwellEditor component.
- */
-interface InkwellEditorProps {
-    /**
-     * Markdown content string
-     */
+type RehypePlugin = Plugin<any[], any>;
+type RehypePluginConfig = RehypePlugin | [RehypePlugin, ...unknown[]];
+interface InkwellEditorState {
+    /** Current source content. Markdown syntax is part of the content. */
     content: string;
-    /**
-     * Called with serialized markdown on every document change
-     */
+    /** True when the editor has no non-whitespace content. */
+    isEmpty: boolean;
+    /** True when the Slate editable is focused. */
+    isFocused: boolean;
+    /** True when user edits are enabled. */
+    isEditable: boolean;
+    /** Current source content character count. */
+    characterCount: number;
+    /** Configured character limit, if any. */
+    characterLimit?: number;
+    /** True when `characterCount` exceeds `characterLimit`. */
+    overLimit: boolean;
+}
+interface InkwellEditorFocusOptions {
+    /** Where to place the caret after focusing. Defaults to preserving selection. */
+    at?: "start" | "end";
+}
+interface InkwellPluginPlaceholder {
+    /** Placeholder text shown by Slate while the editor is empty. */
+    text: string;
+    /** Optional hint prepended to the placeholder text. */
+    hint?: string;
+}
+type InkwellContentSelectionOptions = {
+    select?: "start" | "end" | "preserve";
+};
+interface InkwellEditorHandle {
+    /** Return a snapshot of current editor state. */
+    getState: () => InkwellEditorState;
+    /** Focus the editor and optionally move the caret. */
+    focus: (options?: InkwellEditorFocusOptions) => void;
+    /** Replace the document with empty content without calling onChange. */
+    clear: (options?: InkwellContentSelectionOptions) => void;
+    /** Replace the current document content without calling onChange. */
+    setContent: (content: string, options?: InkwellContentSelectionOptions) => void;
+    /** Insert content at the current selection. */
+    insertContent: (content: string) => void;
+}
+interface InkwellEditorClassNames {
+    /** Class added to the root wrapper. */
+    root?: string;
+    /** Class added to the editable surface. */
+    editor?: string;
+}
+interface InkwellEditorStyles {
+    /** Inline styles applied to the root wrapper. */
+    root?: CSSProperties;
+    /** Inline styles applied to the editable surface. */
+    editor?: CSSProperties;
+}
+interface InkwellHeadingFeatures {
+    h1?: boolean;
+    h2?: boolean;
+    h3?: boolean;
+    h4?: boolean;
+    h5?: boolean;
+    h6?: boolean;
+}
+/** Controls which Markdown features the editor recognizes. */
+interface InkwellFeatures {
+    /** Recognize heading markers. Pass per-level overrides for granular control. */
+    headings?: boolean | InkwellHeadingFeatures;
+    /** Recognize `> ` as blockquotes. */
+    blockquotes?: boolean;
+    /** Recognize fenced code blocks. */
+    codeBlocks?: boolean;
+    /** Recognize standalone image syntax as block images. */
+    images?: boolean;
+}
+interface InkwellEditorProps {
+    /** Source content string. Markdown syntax is part of the content. */
+    content?: string;
+    /** Called with source content on every document change. */
     onChange?: (content: string) => void;
-    /**
-     * Additional CSS class for the wrapper element
-     */
+    /** Called with a full editor state snapshot whenever content, focus, or editability changes. */
+    onStateChange?: (state: InkwellEditorState) => void;
+    /** Additional CSS class for the root wrapper. Alias for `classNames.root`. */
     className?: string;
-    /**
-     * Placeholder text shown when editor is empty
-     */
+    /** Additional CSS classes for editor slots. */
+    classNames?: InkwellEditorClassNames;
+    /** Inline styles for editor slots. */
+    styles?: InkwellEditorStyles;
+    /** Placeholder text shown when editor is empty. */
     placeholder?: string;
-    /**
-     * Editor plugins (bubble toolbar, snippets, custom)
-     */
+    /** Whether users can edit the document. Defaults to true. */
+    editable?: boolean;
+    /** Editor plugins. */
     plugins?: InkwellPlugin[];
-    /**
-     * Custom rehype plugins for the syntax highlighting pipeline
-     */
-    rehypePlugins?: RehypePluginConfig$1[];
-    /**
-     * Configure which block-level decorations the editor recognizes. All enabled by default.
-     */
-    decorations?: InkwellDecorations;
-    /**
-     * Enable real-time collaborative editing via Yjs
-     */
-    collaboration?: CollaborationConfig;
-    /**
-     * Include the built-in bubble menu plugin (default: true). Pass `false` to
-     * disable the built-in toolbar; consumers can still add their own via `plugins`.
-     */
+    /** Custom rehype plugins for the syntax highlighting pipeline. */
+    rehypePlugins?: RehypePluginConfig[];
+    /** Configure which Markdown features the editor recognizes. */
+    features?: InkwellFeatures;
+    /** Include the built-in bubble menu plugin. Defaults to true. */
     bubbleMenu?: boolean;
+    /** Soft character budget. Typing, paste, and inserts past the limit are allowed. */
+    characterLimit?: number;
+    /** Called on every document change with the current character count and configured limit. */
+    onCharacterCount?: (count: number, limit?: number) => void;
+    /** When true, Enter submits the editor instead of inserting a newline. */
+    submitOnEnter?: boolean;
+    /** Called when submitOnEnter handles Enter. */
+    onSubmit?: (content: string) => void;
 }
-/**
- * Props for the InkwellRenderer component.
- */
 interface InkwellRendererProps {
-    /**
-     * Markdown content string
-     */
+    /** Markdown source content string. */
     content: string;
-    /**
-     * Additional CSS class for the wrapper element
-     */
+    /** Additional CSS class for the wrapper element. */
     className?: string;
-    /**
-     * Custom component overrides for rendered markdown elements
-     */
+    /** Custom component overrides for rendered markdown elements. */
     components?: InkwellComponents;
-    /**
-     * Custom rehype plugins for the markdown pipeline
-     */
-    rehypePlugins?: RehypePluginConfig$1[];
-    /**
-     * Show a copy button on fenced code blocks (default: true)
-     */
-    copyButton?: boolean;
+    /** Custom rehype plugins for the markdown pipeline. */
+    rehypePlugins?: RehypePluginConfig[];
+    /** Mention patterns to expand in rendered text. */
+    mentions?: MentionRenderer[];
+}
+interface ParseMarkdownOptions {
+    components?: InkwellComponents;
+    rehypePlugins?: RehypePluginConfig[];
+    mentions?: MentionRenderer[];
+}
+interface MentionRenderer {
+    /** Regular expression applied to text-node content. */
+    pattern: RegExp;
+    /** Map a match to a React node (rendered in place of the match text). */
+    resolve: (match: RegExpExecArray) => ReactNode;
 }
-/**
- * Map of HTML element names to custom React components
- */
 type InkwellComponents = Partial<{
     [K in keyof JSX.IntrinsicElements]: (props: JSX.IntrinsicElements[K] & {
         children?: ReactNode;
     }) => ReactNode;
 }>;
-/**
- * Keyboard trigger for a plugin.
- *
- * Uses tinykeys-style key strings:
- * - `"Control+/"` — modifier combo, prevents default
- * - `"@"` — single character, typed into editor (e.g. for mentions)
- */
-interface PluginTrigger {
-    /**
-     * Key combo (tinykeys format)
-     */
+type InkwellPluginActivation = {
+    type: "always";
+} | {
+    type: "trigger";
     key: string;
+} | {
+    type: "manual";
+};
+type SubscribeForwardedKey = (listener: (key: string) => void) => () => void;
+interface InkwellPluginEditor {
+    getState: () => InkwellEditorState;
+    isEmpty: () => boolean;
+    focus: (options?: InkwellEditorFocusOptions) => void;
+    clear: (options?: InkwellContentSelectionOptions) => void;
+    setContent: (content: string, options?: InkwellContentSelectionOptions) => void;
+    insertContent: (content: string) => void;
+    getContentBeforeCursor: () => string | null;
+    getCurrentBlockContent: () => string | null;
+    getCurrentBlockContentBeforeCursor: () => string | null;
+    replaceCurrentBlockContent: (content: string) => void;
+    clearCurrentBlock: () => void;
+    wrapSelection: (before: string, after: string) => void;
+    insertImage: (image: {
+        id?: string;
+        url: string;
+        alt: string;
+    }) => string;
+    updateImage: (id: string, image: {
+        url?: string;
+        alt?: string;
+    }) => void;
+    removeImage: (id: string) => void;
 }
-/**
- * Props passed to every plugin's render function on every render
- */
 interface PluginRenderProps {
-    /**
-     * Whether this plugin's trigger has fired (always true for plugins without triggers)
-     */
+    /** Whether this plugin is active. Always-on plugins receive true every render. */
     active: boolean;
-    /**
-     * Text typed after the trigger fired
-     */
+    /** Content typed after the trigger fired. */
     query: string;
-    /**
-     * Insert text into the editor at the current cursor position
-     */
-    onSelect: (text: string) => void;
-    /**
-     * Deactivate this plugin (resets `active` to false)
-     */
+    /** Insert content into the editor at the current cursor position. */
+    onSelect: (content: string) => void;
+    /** Deactivate this plugin. */
     onDismiss: () => void;
-    /**
-     * Cursor position when the trigger fired
-     */
+    /** Cursor position when the trigger fired. */
     position: {
         top: number;
         left: number;
     };
-    /**
-     * Ref to the editor's contenteditable element
-     */
+    /** Ref to the editable DOM element. */
     editorRef: RefObject<HTMLDivElement | null>;
-    /**
-     * Wrap the current selection with markdown markers
-     */
+    /** Narrow editor controller for plugin actions. */
+    editor: InkwellPluginEditor;
+    /** Wrap the current selection with markdown markers. */
     wrapSelection: (before: string, after: string) => void;
+    /** Subscribe to editor-forwarded keystrokes while this plugin is active. */
+    subscribeForwardedKey: SubscribeForwardedKey;
+}
+interface PluginInsertDataContext {
+    /** Narrow editor controller for plugin actions. */
+    editor: InkwellPluginEditor;
+    /** Continue with the editor's default paste/drop handling. */
+    insertData: (data: DataTransfer) => void;
 }
-/**
- * Context passed to a plugin's `onKeyDown` handler.
- */
 interface PluginKeyDownContext {
-    /**
-     * Wrap the current selection with markdown markers
-     */
+    /** Narrow editor controller for plugin actions. */
+    editor: InkwellPluginEditor;
+    /** Wrap the current selection with markdown markers. */
     wrapSelection: (before: string, after: string) => void;
+    /** Activate the current plugin. */
+    activate: (options?: {
+        query?: string;
+    }) => void;
+    /** Dismiss the active plugin. */
+    dismiss: () => void;
 }
-/**
- * A Inkwell editor plugin.
- *
- * Every plugin is always rendered. Plugins with a `trigger` receive
- * `active: true` when the trigger fires and `active: false` otherwise.
- * Plugins without a trigger always receive `active: true`.
- */
 interface InkwellPlugin {
-    /**
-     * Unique plugin name
-     */
+    /** Unique plugin name. */
     name: string;
-    /**
-     * Optional keyboard trigger
-     */
-    trigger?: PluginTrigger;
-    /**
-     * Render the plugin UI. Return `null` when inactive.
-     */
-    render: (props: PluginRenderProps) => ReactNode;
-    /**
-     * Optional keydown handler. Runs for events on the editor before trigger
-     * matching, and is skipped while another plugin is active. Call
-     * `event.preventDefault()` to stop further dispatch for this event.
-     */
+    /** Activation behavior. Defaults to `{ type: "always" }`. */
+    activation?: InkwellPluginActivation;
+    /** Render the plugin UI. Omit for headless plugins. */
+    render?: (props: PluginRenderProps) => ReactNode;
+    /** Optional dynamic placeholder. */
+    getPlaceholder?: (editor: InkwellPluginEditor) => string | InkwellPluginPlaceholder | null;
+    /** Optional guard for trigger activation. */
+    shouldTrigger?: (event: KeyboardEvent, ctx: PluginKeyDownContext) => boolean;
+    /** Optional document-change hook. */
+    onEditorChange?: (editor: InkwellPluginEditor) => void;
+    /** Optional keydown handler. */
     onKeyDown?: (event: KeyboardEvent, ctx: PluginKeyDownContext) => void;
+    /** Optional keydown handler while this plugin is active. */
+    onActiveKeyDown?: (event: KeyboardEvent, ctx: PluginKeyDownContext) => false | void;
+    /** Optional paste/drop hook. Return true when the data was handled. */
+    onInsertData?: (data: DataTransfer, ctx: PluginInsertDataContext) => boolean | void;
+    /** Optional one-time setup. */
+    setup?: (editor: InkwellPluginEditor) => void | (() => void);
 }
-/**
- * Props passed to each bubble menu item component.
- */
 interface BubbleMenuItemProps {
-    /**
-     * Wrap or unwrap the current selection with markdown markers. Toggles if already wrapped.
-     */
+    /** Wrap or unwrap the current selection with markdown markers. */
     wrapSelection: (before: string, after: string) => void;
 }
-/**
- * An item in the bubble menu.
- */
 interface BubbleMenuItem {
-    /**
-     * Unique key for React reconciliation
-     */
     key: string;
-    /**
-     * Optional keyboard shortcut (single key, used with Cmd/Ctrl).
-     */
     shortcut?: string;
-    /**
-     * Action to run when the shortcut fires. Receives wrapSelection.
-     */
     onShortcut?: (wrapSelection: (before: string, after: string) => void) => void;
-    /**
-     * React component to render in the menu. Receives `wrapSelection`.
-     */
     render: (props: BubbleMenuItemProps) => ReactNode;
 }
-/**
- * Snippet item for the snippets plugin
- */
 interface Snippet {
-    /**
-     * Display title (searchable)
-     */
     title: string;
-    /**
-     * Markdown content to insert
-     */
     content: string;
 }
+
 /**
- * Controls which markdown block elements the editor recognizes.
- * All decorations are enabled by default. Pass `false` to disable.
+ * Public wrapper. Returns `null` during SSR so all hooks in the client
+ * component below are always called in the same order on the client.
  */
-interface InkwellDecorations {
-    /**
-     * Recognize `# ` as h1 (default: true)
-     */
-    heading1?: boolean;
-    /**
-     * Recognize `## ` as h2 (default: true)
-     */
-    heading2?: boolean;
-    /**
-     * Recognize `### ` as h3 (default: true)
-     */
-    heading3?: boolean;
-    /**
-     * Recognize `#### ` as h4 (default: true)
-     */
-    heading4?: boolean;
+declare const InkwellEditor: react.ForwardRefExoticComponent<InkwellEditorProps & react.RefAttributes<InkwellEditorHandle>>;
+
+type AttachmentUploadResult = string | {
+    url: string;
+    alt?: string;
+    [key: string]: unknown;
+};
+interface Attachment {
+    url: string;
+    filename: string;
+    mime: string;
+    size: number;
+    /**
+     * Any extra fields returned from `onUpload` (e.g. a service-side
+     * record ID) are forwarded onto the attachment.
+     */
+    [key: string]: unknown;
+}
+interface AttachmentsPluginOptions {
     /**
-     * Recognize `##### ` as h5 (default: true)
+     * Upload a single file and resolve to the public URL, or an object
+     * containing the URL plus optional metadata. Rejection triggers
+     * `onError`.
      */
-    heading5?: boolean;
+    onUpload: (file: File) => Promise<AttachmentUploadResult>;
     /**
-     * Recognize `###### ` as h6 (default: true)
+     * MIME-type filter. Accepts exact matches (`image/png`) and wildcards
+     * (`image/*`). Files that don't match pass through untouched.
      */
-    heading6?: boolean;
+    accept?: string;
     /**
-     * Recognize `- `, `* `, `+ ` as list items (default: true)
+     * Placeholder alt text shown on the inserted image element while an
+     * image upload is in flight. Defaults to `"Uploading…"`.
      */
-    lists?: boolean;
+    uploadingPlaceholder?: (file: File) => string;
     /**
-     * Recognize `> ` as blockquotes (default: true)
+     * Fired after a non-image file finishes uploading. Use this to track
+     * attachments in your own state for message submission, chip UI, etc.
+     *
+     * Image files (MIME `image/*`) are inserted inline as `<img>` and do
+     * NOT fire this callback. If omitted, non-image files are passed
+     * through to the editor's default paste/drop handling instead of
+     * being silently uploaded and discarded.
      */
-    blockquotes?: boolean;
+    onAttachmentAdd?: (attachment: Attachment) => void;
     /**
-     * Recognize ``` fences as code blocks (default: true)
+     * Called when `onUpload` rejects, or when the returned URL fails the
+     * URL safety allowlist. For image uploads, the placeholder element is
+     * removed before this fires.
      */
-    codeBlocks?: boolean;
+    onError?: (error: unknown, file: File) => void;
 }
 /**
- * Configuration for real-time collaborative editing via Yjs.
- *
- * The consumer owns the Yjs document and provider (WebSocket,
- * WebRTC, Hocuspocus, etc.). Inkwell only needs the shared type
- * and awareness instance.
+ * Intercepts file paste/drop, uploads via `onUpload`, and either
+ * inserts an inline image element (for `image/*` files) or fires
+ * `onAttachmentAdd` (for non-image files). Non-image files with no
+ * `onAttachmentAdd` callback pass through to the editor's default
+ * paste/drop handling.
  */
-interface CollaborationConfig {
-    /**
-     * Yjs shared type for the document. Create via `doc.get("content", Y.XmlText)`.
-     */
-    sharedType: XmlText;
-    /**
-     * Awareness instance for remote cursor/presence sharing.
-     */
-    awareness: Awareness;
-    /**
-     * Local user metadata, displayed on remote cursors.
-     */
-    user: {
-        name: string;
-        color: string;
-    };
-}
+declare function createAttachmentsPlugin(options: AttachmentsPluginOptions): InkwellPlugin;
 
-declare function InkwellEditor$1({ content, onChange, className, placeholder, plugins: userPlugins, rehypePlugins, decorations, collaboration, bubbleMenu, }: InkwellEditorProps): ReactNode;
-
-/**
- * Element types in the Inkwell editor
- */
-type ElementType = "paragraph" | "code-fence" | "code-line" | "blockquote" | "list-item" | "heading";
 /**
- * A block-level element in the editor
+ * Default bubble menu items: bold, italic, strikethrough.
  */
-interface InkwellElement extends BaseElement {
-    type: ElementType;
-    /**
-     * Unique element identifier. Session-scoped, not persisted in markdown.
-     */
-    id: string;
+declare const defaultBubbleMenuItems: BubbleMenuItem[];
+interface BubbleMenuOptions {
     /**
-     * Heading level (1-6). Only present on `heading` elements.
+     * Menu items. Defaults to bold, italic, strikethrough.
      */
-    level?: number;
-    children: InkwellText[];
+    items?: BubbleMenuItem[];
 }
-/**
- * A text leaf node
- */
-interface InkwellText extends BaseText {
-    text: string;
-    bold?: true;
-    italic?: true;
-    strikethrough?: true;
-    inlineCode?: true;
-    boldMarker?: true;
-    italicMarker?: true;
-    strikeMarker?: true;
-    codeMarker?: true;
-    hljs?: string;
-    remoteCursor?: string;
-    remoteCursorCaret?: boolean;
+declare function createBubbleMenuPlugin(options?: BubbleMenuOptions): InkwellPlugin;
+
+interface CompletionsPluginOptions {
+    /** Unique plugin name. Defaults to `completions`. */
+    name?: string;
+    /** Completion content to render as placeholder text. Return null when inactive. */
+    getCompletion: () => string | null;
+    /** Whether to show a loading placeholder while no completion is available. */
+    isLoading?: () => boolean;
+    /** Text shown while `isLoading()` is true. */
+    loadingText?: string;
+    /** Hint rendered while the completion placeholder is visible. */
+    acceptHint?: string;
+    /** Called after Tab accepts and inserts the completion. */
+    onAccept?: (completion: string) => void;
+    /** Called when Escape or user typing dismisses the current completion. */
+    onDismiss?: (completion: string) => void;
+    /**
+     * Called when an accepted completion is undone back to an empty document.
+     * Enabled by default; set `restoreOnUndo` to false to opt out.
+     */
+    onRestore?: (completion: string) => void;
+    /** Whether undo-to-empty should restore the accepted completion. Defaults to true. */
+    restoreOnUndo?: boolean;
 }
-/**
- * The composed Inkwell editor type
- */
-type InkwellEditor = BaseEditor & ReactEditor & HistoryEditor;
-declare module "slate" {
-    interface CustomTypes {
-        Editor: InkwellEditor;
-        Element: InkwellElement;
-        Text: InkwellText;
-    }
+declare function createCompletionsPlugin({ name, getCompletion, isLoading, loadingText, acceptHint, onAccept, onDismiss, onRestore, restoreOnUndo, }: CompletionsPluginOptions): InkwellPlugin;
+
+interface EmojiItem {
+    /** Emoji glyph inserted into the document. */
+    emoji: string;
+    /** Primary searchable name, without surrounding colons. */
+    name: string;
+    /** Optional aliases/shortcodes, without surrounding colons. */
+    shortcodes?: string[];
+    /** Optional searchable tags. */
+    tags?: string[];
+}
+interface EmojiPluginBaseOptions<T extends EmojiItem> {
+    name?: string;
+    trigger?: string;
+    renderItem?: (item: T, active: boolean) => ReactNode;
+    emptyMessage?: string;
 }
+type IsExactEmojiItem<T extends EmojiItem> = EmojiItem extends T ? T extends EmojiItem ? true : false : false;
+type EmojiPluginOptions<T extends EmojiItem = EmojiItem> = EmojiPluginBaseOptions<T> & (IsExactEmojiItem<T> extends true ? {
+    emojis?: T[];
+    search?: (query: string) => Promise<T[]> | T[];
+} : {
+    emojis: T[];
+    search?: (query: string) => Promise<T[]> | T[];
+} | {
+    emojis?: T[];
+    search: (query: string) => Promise<T[]> | T[];
+});
+declare const defaultEmojis: EmojiItem[];
+declare function createEmojiPlugin<T extends EmojiItem>(options: EmojiPluginOptions<T>): InkwellPlugin;
+declare function createEmojiPlugin(options?: EmojiPluginOptions): InkwellPlugin;
 
 /**
- * Deserialize a markdown string into Slate decorations.
- *
- * Each line becomes its own element. Block-level patterns (code fences,
- * blockquotes, list items, headings) get their own element types based
- * on the `decorations` config. Everything else is a paragraph. Text content
- * is stored verbatim — visual formatting is handled by decorations at
- * render time, not in the data model.
+ * Item shape a mentions plugin operates on. `id` is required so the default
+ * reference-marker form (`@<marker>[<id>]`) has something to persist.
  */
-declare function deserialize(markdown: string, decorations?: InkwellDecorations): InkwellElement[];
-
-declare function pluginClass(pluginName: string): (component: string) => string;
-
+interface MentionItem {
+    id: string;
+    title: string;
+}
+interface MentionsPluginOptions<T extends MentionItem = MentionItem> {
+    /** Unique plugin name. Defaults to `mentions`. */
+    name?: string;
+    /** Key that opens the picker. Defaults to `@`. */
+    trigger?: string;
+    /**
+     * Persisted marker name used when `onSelect` is not provided. Produces
+     * `@<marker>[<id>]` in the document. Defaults to `mention`.
+     */
+    marker?: string;
+    /** Async search callback. Return items matching the query. */
+    search: (query: string) => Promise<T[]> | T[];
+    /** Render a single item row in the picker. */
+    renderItem: (item: T, active: boolean) => ReactNode;
+    /**
+     * Map a selected item to the string inserted into the document. When
+     * omitted, the plugin inserts the marker form `@<marker>[<id>]`.
+     */
+    onSelect?: (item: T) => string;
+    /** Fallback message when `search` returns no results. */
+    emptyMessage?: string;
+}
 /**
- * Default bubble menu items: bold, italic, strikethrough.
+ * Generic mentions plugin. Pick items from an async source and insert either
+ * the expanded content (via `onSelect`) or a persisted marker `@<marker>[<id>]`.
  */
-declare const defaultBubbleMenuItems: BubbleMenuItem[];
-interface BubbleMenuOptions {
-    /**
-     * Menu items. Defaults to bold, italic, strikethrough.
-     */
-    items?: BubbleMenuItem[];
+declare function createMentionsPlugin<T extends MentionItem = MentionItem>(options: MentionsPluginOptions<T>): InkwellPlugin;
+
+interface SlashCommandChoice {
+    value: string;
+    label: string;
+    disabled?: boolean;
 }
-declare function createBubbleMenuPlugin(options?: BubbleMenuOptions): InkwellPlugin;
+interface SlashCommandArg {
+    name: string;
+    description: string;
+    choices?: SlashCommandChoice[];
+    fetchChoices?: () => Promise<SlashCommandChoice[]>;
+}
+interface SlashCommandItem {
+    name: string;
+    description: string;
+    aliases?: string[];
+    arg?: SlashCommandArg;
+    disabled?: () => string | false;
+}
+interface SlashCommandExecution {
+    name: string;
+    args: Record<string, string>;
+    raw: string;
+}
+interface SlashCommandsPluginOptions<T extends SlashCommandItem = SlashCommandItem> {
+    /** Plugin name. Defaults to `"slash-commands"`. */
+    name?: string;
+    /** Commands shown in the picker. */
+    commands: T[];
+    /** Called whenever the menu transitions in and out of the execute phase. */
+    onReadyChange?: (ready: boolean) => void;
+    /** Called with the structured execution payload when the user presses Enter
+     *  during the execute phase. */
+    onExecute?: (command: SlashCommandExecution) => void;
+    /** Fallback message when filtering returns no commands. */
+    emptyMessage?: string;
+}
+declare const createSlashCommandsPlugin: <T extends SlashCommandItem>({ name, commands, onReadyChange, onExecute, emptyMessage, }: SlashCommandsPluginOptions<T>) => InkwellPlugin;
 
-declare function createSnippetsPlugin(options: {
+interface SnippetsPluginOptions {
+    name?: string;
+    trigger?: string;
     snippets: Snippet[];
-    key?: string;
-}): InkwellPlugin;
+}
+declare function createSnippetsPlugin({ snippets, name, trigger, }: SnippetsPluginOptions): InkwellPlugin;
 
 /**
  * Convert an HTML string to a markdown string
  */
-declare function serializeToMarkdown(html: string): string;
+declare function htmlToMarkdown(html: string): string;
 
-declare function InkwellRenderer({ content, className, components, rehypePlugins, copyButton, }: InkwellRendererProps): ReactNode;
+declare function InkwellRenderer({ content, className, components, rehypePlugins, mentions, }: InkwellRendererProps): ReactNode;
 
-type RehypePlugin = Plugin<any[], any>;
-type RehypePluginConfig = RehypePlugin | [RehypePlugin, Record<string, unknown>];
 /**
  * Parse a markdown string into React elements synchronously
  */
-declare function parseMarkdown(markdown: string, components?: InkwellComponents, rehypePlugins?: RehypePluginConfig[]): ReactNode;
+declare function parseMarkdown(content: string, options?: ParseMarkdownOptions): ReactNode;
 
-export { type BubbleMenuItem, type BubbleMenuItemProps, type CollaborationConfig, type InkwellComponents, type InkwellDecorations, InkwellEditor$1 as InkwellEditor, type InkwellEditorProps, type InkwellPlugin, InkwellRenderer, type InkwellRendererProps, type PluginKeyDownContext, type PluginRenderProps, type PluginTrigger, type RehypePluginConfig$1 as RehypePluginConfig, type Snippet, createBubbleMenuPlugin, createSnippetsPlugin, defaultBubbleMenuItems, deserialize, parseMarkdown, pluginClass, serializeToMarkdown };
+export { type Attachment, type AttachmentUploadResult, type AttachmentsPluginOptions, type BubbleMenuItem, type BubbleMenuItemProps, type BubbleMenuOptions, type CompletionsPluginOptions, type EmojiItem, type EmojiPluginOptions, type InkwellComponents, InkwellEditor, type InkwellEditorClassNames, type InkwellEditorFocusOptions, type InkwellEditorHandle, type InkwellEditorProps, type InkwellEditorState, type InkwellEditorStyles, type InkwellFeatures, type InkwellPlugin, type InkwellPluginActivation, type InkwellPluginEditor, type InkwellPluginPlaceholder, InkwellRenderer, type InkwellRendererProps, type MentionItem, type MentionRenderer, type MentionsPluginOptions, type ParseMarkdownOptions, type PluginInsertDataContext, type PluginKeyDownContext, type PluginRenderProps, type RehypePluginConfig, type SlashCommandArg, type SlashCommandChoice, type SlashCommandExecution, type SlashCommandItem, type SlashCommandsPluginOptions, type Snippet, type SnippetsPluginOptions, type SubscribeForwardedKey, createAttachmentsPlugin, createBubbleMenuPlugin, createCompletionsPlugin, createEmojiPlugin, createMentionsPlugin, createSlashCommandsPlugin, createSnippetsPlugin, defaultBubbleMenuItems, defaultEmojis, htmlToMarkdown, parseMarkdown };