@wakastellar/ui 3.3.3 → 3.5.0

package/dist/src/components/editor/waka-document-editor.d.ts

@@ -0,0 +1,92 @@
+import * as React from "react";
+type SlateNode = any;
+/** TOC entry extracted from headings */
+export interface TocEntry {
+    id: string;
+    text: string;
+    level: number;
+    depth: number;
+}
+export interface WakaDocumentEditorProps {
+    /** Initial Slate content */
+    value?: SlateNode[];
+    /** Change callback */
+    onChange?: (value: SlateNode[]) => void;
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Placeholder */
+    placeholder?: string;
+    /** CSS class for the root layout */
+    className?: string;
+    /** CSS class for the editor area */
+    editorClassName?: string;
+    /** Minimum height in px */
+    minHeight?: number;
+    /** Label */
+    label?: string;
+    /** Description */
+    description?: string;
+    /** Error message */
+    error?: string;
+    /** Document title (displayed in the header) */
+    title?: string;
+    /** Callback when title changes */
+    onTitleChange?: (title: string) => void;
+    /** Show TOC sidebar */
+    showTOC?: boolean;
+    /** Enable @mentions */
+    enableMentions?: boolean;
+    /** Mention search function. Returns matching users for a query string. */
+    onMentionSearch?: (query: string) => Promise<Array<{
+        key: string;
+        label: string;
+        avatar?: string;
+    }>>;
+    /** Enable slash commands */
+    enableSlashCommands?: boolean;
+    /** Enable AI features */
+    enableAI?: boolean;
+    /** AI endpoint for AI features */
+    aiEndpoint?: string;
+    /** System prompt for AI */
+    aiSystemPrompt?: string;
+    /** Enable DnD block reordering */
+    enableDnD?: boolean;
+    /** Enable markdown paste support */
+    enableMarkdown?: boolean;
+    /** Extra Plate plugins */
+    extraPlugins?: any[];
+    /** Ref to the editor instance */
+    editorRef?: React.MutableRefObject<any>;
+}
+/**
+ * WakaDocumentEditor -- Google-Docs-style full document editor.
+ *
+ * Features:
+ * - Fixed toolbar with formatting controls
+ * - Optional TOC sidebar (auto-extracted from headings)
+ * - @mentions with async user search
+ * - Slash commands (/) for quick block insertion
+ * - Drag-and-drop block reordering
+ * - AI integration (optional)
+ * - Markdown paste support
+ *
+ * Perfect for writing specifications, proposals, documentation,
+ * or any long-form content within WakaStart apps.
+ *
+ * @example
+ * ```tsx
+ * <WakaDocumentEditor
+ *   title="Architecture Specification"
+ *   onTitleChange={setTitle}
+ *   showTOC
+ *   enableMentions
+ *   enableSlashCommands
+ *   enableDnD
+ *   value={content}
+ *   onChange={setContent}
+ * />
+ * ```
+ */
+export declare const WakaDocumentEditor: React.ForwardRefExoticComponent<WakaDocumentEditorProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/src/components/editor/waka-editor-elements.d.ts

@@ -0,0 +1,79 @@
+import * as React from "react";
+export interface PlateElementProps {
+    attributes?: Record<string, unknown>;
+    children?: React.ReactNode;
+    element?: Record<string, unknown>;
+    className?: string;
+}
+export declare function TableElement({ children, attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace TableElement {
+    var displayName: string;
+}
+export declare function TableRowElement({ children, attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace TableRowElement {
+    var displayName: string;
+}
+export declare function TableCellElement({ children, attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace TableCellElement {
+    var displayName: string;
+}
+export declare function TableCellHeaderElement({ children, attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace TableCellHeaderElement {
+    var displayName: string;
+}
+export declare function ColumnGroupElement({ children, attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ColumnGroupElement {
+    var displayName: string;
+}
+export declare function ColumnElement({ children, attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ColumnElement {
+    var displayName: string;
+}
+export declare function CalloutElement({ children, attributes, element, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace CalloutElement {
+    var displayName: string;
+}
+export declare function H1Element({ children, attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace H1Element {
+    var displayName: string;
+}
+export declare function H2Element({ children, attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace H2Element {
+    var displayName: string;
+}
+export declare function H3Element({ children, attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace H3Element {
+    var displayName: string;
+}
+export declare function H4Element({ children, attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace H4Element {
+    var displayName: string;
+}
+export declare function H5Element({ children, attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace H5Element {
+    var displayName: string;
+}
+export declare function H6Element({ children, attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace H6Element {
+    var displayName: string;
+}
+export declare function BlockquoteElement({ children, attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace BlockquoteElement {
+    var displayName: string;
+}
+export declare function ParagraphElement({ children, attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ParagraphElement {
+    var displayName: string;
+}
+export declare function LinkElement({ children, attributes, element, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace LinkElement {
+    var displayName: string;
+}
+export declare function MentionElement({ children, attributes, element, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace MentionElement {
+    var displayName: string;
+}
+export declare function SeparatorElement({ attributes, className }: PlateElementProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SeparatorElement {
+    var displayName: string;
+}

package/dist/src/components/editor/waka-editor-leaves.d.ts

@@ -0,0 +1,39 @@
+import * as React from "react";
+export interface PlateLeafProps {
+    attributes?: Record<string, unknown>;
+    children?: React.ReactNode;
+    leaf?: Record<string, unknown>;
+    className?: string;
+}
+export declare function BoldLeaf({ children, attributes, className }: PlateLeafProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace BoldLeaf {
+    var displayName: string;
+}
+export declare function ItalicLeaf({ children, attributes, className }: PlateLeafProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ItalicLeaf {
+    var displayName: string;
+}
+export declare function UnderlineLeaf({ children, attributes, className }: PlateLeafProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace UnderlineLeaf {
+    var displayName: string;
+}
+export declare function StrikethroughLeaf({ children, attributes, className }: PlateLeafProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace StrikethroughLeaf {
+    var displayName: string;
+}
+export declare function CodeLeaf({ children, attributes, className }: PlateLeafProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace CodeLeaf {
+    var displayName: string;
+}
+export declare function HighlightLeaf({ children, attributes, className }: PlateLeafProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace HighlightLeaf {
+    var displayName: string;
+}
+export declare function SuperscriptLeaf({ children, attributes, className }: PlateLeafProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SuperscriptLeaf {
+    var displayName: string;
+}
+export declare function SubscriptLeaf({ children, attributes, className }: PlateLeafProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SubscriptLeaf {
+    var displayName: string;
+}

package/dist/src/components/editor/waka-editor-plugins.d.ts

@@ -0,0 +1,41 @@
+import { PlatePlugin } from 'platejs/react';
+/**
+ * Dynamically loads the core formatting plugins (marks + block elements).
+ * These are always included in the editor.
+ */
+export declare function loadCorePlugins(): Promise<PlatePlugin[]>;
+/** Loads the link plugin */
+export declare function loadLinkPlugin(): Promise<PlatePlugin[]>;
+/** Loads media plugins (image, video, embed) */
+export declare function loadMediaPlugins(): Promise<PlatePlugin[]>;
+/** Loads mention plugins */
+export declare function loadMentionPlugins(): Promise<PlatePlugin[]>;
+/** Loads DnD (drag and drop) plugin */
+export declare function loadDndPlugin(): Promise<PlatePlugin[]>;
+/** Loads TOC (table of contents) plugin */
+export declare function loadTocPlugin(): Promise<PlatePlugin[]>;
+/** Loads indent plugin */
+export declare function loadIndentPlugin(): Promise<PlatePlugin[]>;
+/** Loads markdown serialization plugin */
+export declare function loadMarkdownPlugin(): Promise<PlatePlugin[]>;
+/** Loads selection plugin */
+export declare function loadSelectionPlugin(): Promise<PlatePlugin[]>;
+/** Loads AI plugins (AI menu + AI chat) */
+export declare function loadAIPlugins(options?: {
+    endpoint?: string;
+    systemPrompt?: string;
+    headers?: Record<string, string>;
+}): Promise<PlatePlugin[]>;
+/** Loads emoji plugin */
+export declare function loadEmojiPlugin(): Promise<PlatePlugin[]>;
+/** Loads floating toolbar plugin */
+export declare function loadFloatingPlugin(): Promise<PlatePlugin[]>;
+/** Loads diff plugin for document comparison */
+export declare function loadDiffPlugin(): Promise<PlatePlugin[]>;
+/** Loads combobox/slash-command plugins */
+export declare function loadComboboxPlugins(): Promise<PlatePlugin[]>;
+export type WakaEditorPreset = "minimal" | "standard" | "full";
+/**
+ * Returns the list of optional plugin loaders based on a named preset.
+ */
+export declare function getPresetLoaders(preset: WakaEditorPreset): (typeof loadLinkPlugin)[];

package/dist/src/components/editor/waka-editor-toolbar.d.ts

@@ -0,0 +1,20 @@
+export type ToolbarAction = "bold" | "italic" | "underline" | "strikethrough" | "code" | "highlight" | "h1" | "h2" | "h3" | "blockquote" | "callout" | "table" | "columns" | "link" | "image" | "separator" | "ai";
+/** A group of toolbar buttons rendered together with separators between groups */
+export type ToolbarGroup = ToolbarAction[];
+export interface WakaEditorToolbarProps {
+    /** Button groups to render */
+    groups?: ToolbarGroup[];
+    /** The Plate editor instance (typed as unknown to avoid tight coupling) */
+    editor: unknown;
+    /** Extra CSS class names */
+    className?: string;
+    /** Whether to show AI button */
+    enableAI?: boolean;
+    /** Callback when AI button is clicked */
+    onAIClick?: () => void;
+}
+export declare const DEFAULT_TOOLBAR_GROUPS: ToolbarGroup[];
+export declare function WakaEditorToolbar({ groups, editor, className, enableAI, onAIClick, }: WakaEditorToolbarProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaEditorToolbar {
+    var displayName: string;
+}

package/dist/src/components/editor/waka-editor.d.ts

@@ -0,0 +1,59 @@
+import { ToolbarGroup } from './waka-editor-toolbar';
+import { WakaEditorPreset } from './waka-editor-plugins';
+import * as React from "react";
+/**
+ * Slate/Plate node type. Using a generic type to avoid tight coupling
+ * with Plate internals while remaining compatible.
+ */
+export type SlateNode = any;
+export interface WakaEditorProps {
+    /** Initial content as Slate value */
+    value?: SlateNode[];
+    /** Change callback with updated Slate value */
+    onChange?: (value: SlateNode[]) => void;
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Extra CSS class names on the root container */
+    className?: string;
+    /** Extra CSS class names on the editable area */
+    editorClassName?: string;
+    /** Minimum height of the editable area in px */
+    minHeight?: number;
+    /** Label displayed above the editor */
+    label?: string;
+    /** Description displayed below the label */
+    description?: string;
+    /** Error message */
+    error?: string;
+    /** Named preset: "minimal" | "standard" | "full" (default: "standard") */
+    preset?: WakaEditorPreset;
+    /** Show AI assistant button in toolbar */
+    enableAI?: boolean;
+    /** Enable Yjs collaboration (not yet implemented) */
+    enableCollaboration?: boolean;
+    /** Enable inline comments (not yet implemented) */
+    enableComments?: boolean;
+    /** Enable markdown import/export */
+    enableMarkdown?: boolean;
+    /** Enable image and video embeds */
+    enableMedia?: boolean;
+    /** Enable @mentions */
+    enableMentions?: boolean;
+    /** Enable drag-and-drop reordering */
+    enableDnD?: boolean;
+    /** Enable table of contents generation */
+    enableTOC?: boolean;
+    /** Custom toolbar groups (overrides preset defaults) */
+    toolbarGroups?: ToolbarGroup[];
+    /** Hide the toolbar entirely */
+    hideToolbar?: boolean;
+    /** Callback when AI button is clicked */
+    onAIClick?: () => void;
+    /** Extra Plate plugins to add on top of the preset */
+    extraPlugins?: any[];
+    /** Ref to the internal Plate editor instance */
+    editorRef?: React.MutableRefObject<any>;
+}
+export declare const WakaEditor: React.ForwardRefExoticComponent<WakaEditorProps & React.RefAttributes<HTMLDivElement>>;

package/dist/src/components/editor/waka-floating-toolbar.d.ts

@@ -0,0 +1,47 @@
+import { LucideIcon } from 'lucide-react';
+import * as React from "react";
+/** A button definition for the floating toolbar */
+export interface FloatingToolbarButton {
+    key: string;
+    icon: LucideIcon;
+    label: string;
+    shortcut?: string;
+    /** Execute the action on the editor */
+    action: (editor: any) => void;
+    /** Check if this mark/block is active */
+    isActive?: (editor: any) => boolean;
+}
+export interface WakaFloatingToolbarProps {
+    /** The Plate editor instance */
+    editor: unknown;
+    /** Additional buttons to display */
+    buttons?: FloatingToolbarButton[];
+    /** Whether to show the AI "Ask AI" button */
+    enableAI?: boolean;
+    /** Callback when AI button is clicked */
+    onAIClick?: () => void;
+    /** CSS class */
+    className?: string;
+    /** Whether to show in read-only mode */
+    showWhenReadOnly?: boolean;
+}
+/** Default floating toolbar buttons */
+export declare const DEFAULT_FLOATING_BUTTONS: FloatingToolbarButton[];
+/**
+ * WakaFloatingToolbar -- Floating contextual toolbar that appears on text selection.
+ *
+ * This component should be placed **inside** a `<Plate>` context. It uses
+ * `@platejs/floating`'s `useFloatingToolbar` hook internally when available,
+ * or falls back to a static inline toolbar.
+ *
+ * For the floating behavior to work, the app must install `@platejs/floating`.
+ *
+ * @example
+ * ```tsx
+ * <Plate editor={editor}>
+ *   <WakaFloatingToolbar editor={editor} enableAI onAIClick={handleAI} />
+ *   <PlateContent />
+ * </Plate>
+ * ```
+ */
+export declare const WakaFloatingToolbar: React.ForwardRefExoticComponent<WakaFloatingToolbarProps & React.RefAttributes<HTMLDivElement>>;

package/dist/src/components/editor/waka-markdown-editor.d.ts

@@ -0,0 +1,60 @@
+import * as React from "react";
+type SlateNode = any;
+export type MarkdownEditorMode = "rich" | "markdown" | "split";
+export interface WakaMarkdownEditorProps {
+    /** Markdown string content */
+    markdownValue?: string;
+    /** Callback when markdown content changes */
+    onMarkdownChange?: (markdown: string) => void;
+    /** Slate value (for rich text mode) */
+    slateValue?: SlateNode[];
+    /** Callback when slate value changes */
+    onSlateChange?: (value: SlateNode[]) => void;
+    /** Initial view mode */
+    defaultMode?: MarkdownEditorMode;
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Placeholder */
+    placeholder?: string;
+    /** CSS class */
+    className?: string;
+    /** Editor area CSS class */
+    editorClassName?: string;
+    /** Minimum height in px */
+    minHeight?: number;
+    /** Label */
+    label?: string;
+    /** Description */
+    description?: string;
+    /** Error */
+    error?: string;
+    /** Extra Plate plugins */
+    extraPlugins?: any[];
+    /** Ref to editor instance */
+    editorRef?: React.MutableRefObject<any>;
+}
+/**
+ * WakaMarkdownEditor -- Dual-mode rich text / Markdown editor.
+ *
+ * Transparently syncs content between Plate (rich text) and raw Markdown.
+ * Supports three view modes:
+ * - `rich`: WYSIWYG Plate editor (default)
+ * - `markdown`: Raw Markdown textarea with monospace font
+ * - `split`: Side-by-side Plate + Markdown preview
+ *
+ * Uses `@platejs/markdown` for serialization/deserialization.
+ *
+ * Perfect for developer documentation, README editors,
+ * or any context where users need to switch between rich text and Markdown.
+ *
+ * @example
+ * ```tsx
+ * <WakaMarkdownEditor
+ *   markdownValue={md}
+ *   onMarkdownChange={setMd}
+ *   defaultMode="split"
+ * />
+ * ```
+ */
+export declare const WakaMarkdownEditor: React.ForwardRefExoticComponent<WakaMarkdownEditorProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/src/components/editor/waka-mention-editor.d.ts

@@ -0,0 +1,125 @@
+import * as React from "react";
+type SlateNode = any;
+/** A mentionable user entity */
+export interface MentionableUser {
+    /** Unique ID (e.g., keycloak-id or user wid) */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Email address */
+    email?: string;
+    /** Avatar URL */
+    avatar?: string;
+    /** Role or title (shown in the suggestion list) */
+    role?: string;
+    /** Admin level (for display badge) */
+    adminLevel?: string;
+}
+/** Describes a mention that was inserted into the document */
+export interface InsertedMention {
+    /** The user that was mentioned */
+    user: MentionableUser;
+    /** The Slate path where the mention was inserted */
+    path?: number[];
+}
+export interface WakaMentionEditorProps {
+    /** Initial Slate content */
+    value?: SlateNode[];
+    /** Change callback */
+    onChange?: (value: SlateNode[]) => void;
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Placeholder */
+    placeholder?: string;
+    /** CSS class */
+    className?: string;
+    /** Editor CSS class */
+    editorClassName?: string;
+    /** Minimum height in px */
+    minHeight?: number;
+    /** Label */
+    label?: string;
+    /** Description */
+    description?: string;
+    /** Error */
+    error?: string;
+    /**
+     * Async search function that resolves mentionable users.
+     * Called when the user types after "@".
+     * Should return matching users from the WakaStart API.
+     */
+    onSearch: (query: string) => Promise<MentionableUser[]>;
+    /**
+     * Callback when a mention is inserted.
+     * Can be used to trigger notifications.
+     */
+    onMentionInserted?: (mention: InsertedMention) => void;
+    /**
+     * Trigger character for mentions. Default: "@"
+     */
+    trigger?: string;
+    /**
+     * Debounce delay for the search function in ms.
+     * Default: 300
+     */
+    searchDebounceMs?: number;
+    /**
+     * Maximum number of search results to show.
+     * Default: 8
+     */
+    maxResults?: number;
+    /** Extra Plate plugins */
+    extraPlugins?: any[];
+    /** Ref to editor instance */
+    editorRef?: React.MutableRefObject<any>;
+}
+/**
+ * WakaMentionEditor -- Rich text editor with @mention support.
+ *
+ * Integrates `@platejs/mention` to provide user mention functionality.
+ * When the user types "@", a dropdown with matching users appears.
+ * The search function is async, allowing API-backed user resolution
+ * scoped to the current tenant (Partner > Network > Customer).
+ *
+ * When a mention is inserted, the `onMentionInserted` callback fires,
+ * allowing the app to trigger notifications via ws-back-wakastart.
+ *
+ * The mention element renders as an inline pill with the user's
+ * avatar and name, styled with design system tokens.
+ *
+ * Useful for:
+ * - Spec review comments with @author mentions
+ * - Task assignment in WakaStart projects
+ * - Chat/collaboration features
+ * - Audit notes with @reviewer references
+ *
+ * @example
+ * ```tsx
+ * <WakaMentionEditor
+ *   value={content}
+ *   onChange={setContent}
+ *   onSearch={async (q) => {
+ *     const users = await usersApi.search(q);
+ *     return users.map(u => ({ id: u.wid, name: u.fullName, email: u.email }));
+ *   }}
+ *   onMentionInserted={(m) => {
+ *     notificationsApi.send(m.user.id, "You were mentioned in a document");
+ *   }}
+ * />
+ * ```
+ */
+export declare const WakaMentionEditor: React.ForwardRefExoticComponent<WakaMentionEditorProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Standalone mention suggestion list component.
+ * Can be used outside of WakaMentionEditor for custom integrations.
+ */
+export declare function MentionSuggestions({ suggestions, searching, className, onSelect, }: {
+    suggestions: MentionableUser[];
+    searching?: boolean;
+    className?: string;
+    onSelect?: (user: MentionableUser) => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare namespace MentionSuggestions {
+    var displayName: string;
+}
+export {};

package/dist/src/components/editor/waka-slash-menu.d.ts

@@ -0,0 +1,70 @@
+import { LucideIcon } from 'lucide-react';
+/** A single slash command entry */
+export interface SlashCommand {
+    /** Unique key used for filtering */
+    key: string;
+    /** Display label */
+    label: string;
+    /** Optional description shown below the label */
+    description?: string;
+    /** Lucide icon component */
+    icon: LucideIcon;
+    /** Group name (commands are visually grouped) */
+    group: string;
+    /** Search keywords for filtering */
+    keywords?: string[];
+    /**
+     * Action to execute when the command is selected.
+     * Receives the Plate editor instance.
+     */
+    action: (editor: any) => void;
+}
+export interface WakaSlashMenuProps {
+    /** Commands to display in the menu */
+    commands?: SlashCommand[];
+    /** CSS class for the menu container */
+    className?: string;
+    /** Callback when a command is selected. Receives the command key. */
+    onSelect?: (key: string) => void;
+}
+/** Default slash commands for WakaStart editors */
+export declare const DEFAULT_SLASH_COMMANDS: SlashCommand[];
+/**
+ * WakaSlashMenu -- Configurable slash command palette.
+ *
+ * This component is designed to be used **inside** a Plate editor context
+ * as the combobox renderer for the `@platejs/combobox` SlashPlugin,
+ * or standalone as a command registry.
+ *
+ * When used standalone, provide `onSelect` to receive the selected command key.
+ * The consuming app is responsible for connecting it to the editor.
+ *
+ * @example
+ * ```tsx
+ * <WakaSlashMenu
+ *   commands={[...DEFAULT_SLASH_COMMANDS, myCustomCommand]}
+ *   onSelect={(key) => console.log("Selected:", key)}
+ * />
+ * ```
+ */
+export declare function WakaSlashMenu({ commands, className, onSelect, }: WakaSlashMenuProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaSlashMenu {
+    var displayName: string;
+}
+/**
+ * Creates slash command plugin configuration for Plate.
+ * Call this function and spread the result into your plugins array.
+ *
+ * @example
+ * ```ts
+ * import { createSlashCommandPlugins } from "@wakastellar/ui/editor"
+ *
+ * const editor = usePlateEditor({
+ *   plugins: [
+ *     ...otherPlugins,
+ *     ...await createSlashCommandPlugins(),
+ *   ],
+ * })
+ * ```
+ */
+export declare function createSlashCommandPlugins(commands?: SlashCommand[]): Promise<any[]>;