@surrealdb/ui 1.0.73 → 1.0.75

package/dist/ui.d.ts

@@ -1,46 +1,45 @@
 import { ActionIconProps } from '@mantine/core';
 import { AlertProps } from '@mantine/core';
+import { AnchorProps } from '@mantine/core';
 import { BadgeProps } from '@mantine/core';
+import { BlockquoteElement } from '@yoopta/blockquote';
 import { BoxProps } from '@mantine/core';
 import { ButtonProps } from '@mantine/core';
+import { CalloutElementMap } from '@yoopta/callout/dist/types';
 import { CodeProps } from '@mantine/core';
 import { Command } from '@codemirror/view';
-import { Command as Command_2 } from 'prosemirror-state';
+import { DividerElementMap } from '@yoopta/divider/dist/types';
 import { EditorSelection } from '@codemirror/state';
-import { EditorState } from 'prosemirror-state';
 import { EditorView } from '@codemirror/view';
-import { EditorView as EditorView_2 } from 'prosemirror-view';
 import { ElementProps } from '@mantine/core';
 import { Extension } from '@codemirror/state';
 import { FC } from 'react';
-import { Fragment } from 'prosemirror-model';
 import { GroupProps } from '@mantine/core';
 import { Highlighter } from '@lezer/highlight';
 import { HighlightStyle } from '@codemirror/language';
 import { HTMLAttributes } from 'react';
 import { ImageProps } from '@mantine/core';
-import { InputRule } from 'prosemirror-inputrules';
 import { KeyBinding } from '@codemirror/view';
+import { ListElementMap } from '@yoopta/lists/dist/types';
 import { MantineColor } from '@mantine/core';
 import { MantineColorScheme } from '@mantine/core';
 import { MantineFontSize } from '@mantine/core';
+import { MantineSize } from '@mantine/core';
 import { MantineThemeOverride } from '@mantine/core';
-import { MarkSpec } from 'prosemirror-model';
-import { MarkType } from 'prosemirror-model';
-import { Node as Node_2 } from 'prosemirror-model';
-import { NodeSpec } from 'prosemirror-model';
-import { NodeViewConstructor } from 'prosemirror-view';
 import { PaperProps } from '@mantine/core';
-import { PluginKey } from 'prosemirror-state';
 import type * as React_2 from 'react';
 import { ReactNode } from 'react';
-import { Ref } from 'react';
 import { RefObject } from 'react';
-import { ResolvedPos } from 'prosemirror-model';
-import { Schema } from 'prosemirror-model';
+import { SlateElement } from '@yoopta/editor';
 import { StackProps } from '@mantine/core';
 import { StateField } from '@codemirror/state';
 import { TabsProps as TabsProps_2 } from '@mantine/core';
+import { VideoHTMLAttributes } from 'react';
+import { YooEditor } from '@yoopta/editor';
+import { YooptaContentValue } from '@yoopta/editor';
+import { YooptaMark } from '@yoopta/editor';
+import { YooptaOnChangeOptions } from '@yoopta/editor';
+import { YooptaPlugin } from '@yoopta/editor';
 
 /**
  * A keybind used to accept a completion
@@ -64,6 +63,8 @@ export declare const addCursorVerticallyKeymap: readonly KeyBinding[];
 
 declare type AnyFn = (...rest: any[]) => any;
 
+declare type AnyLanguage = Language | (string & {});
+
 export declare type AnyNode = BlockNode | InlineNode | SummaryNode | ListItemNode | TableRowNode | TableCellNode | TabItemNode;
 
 /**
@@ -73,82 +74,27 @@ export declare type AnyNode = BlockNode | InlineNode | SummaryNode | ListItemNod
  */
 export declare function applyAutoFolding(view: EditorView, autoCollapseDepth: number): void;
 
-/**
- * A block in the editor document. Blocks have a stable `id`,
- * a `type` determining their behavior, `props` for type-specific
- * attributes, optional inline `content`, and optional nested
- * `children` blocks.
- */
-export declare interface Block {
-    id: string;
-    type: BlockType;
-    props: Record<string, unknown>;
-    content?: InlineContent[];
-    children?: Block[];
-}
-
 export declare const BlockEditor: FC<BlockEditorProps>;
 
-/**
- * Controller interface for interacting with a block editor instance.
- * Created by the `useBlockEditor` hook and passed to the `BlockEditor`
- * component.
- */
-export declare interface BlockEditorController {
-    /** Ref to attach to the editor's mount point DOM element (RefObject or callback ref). */
-    ref: Ref<HTMLDivElement | null>;
-    /** Whether the ProseMirror EditorView has been mounted. */
-    mounted: boolean;
-    /** Access the underlying ProseMirror EditorView. Throws if not mounted. */
-    getEditor: () => EditorView_2;
-    /** Convert the current document to a Block[] JSON model. */
-    getBlocks: () => Block[];
-    /** Find a block by ID, searching recursively through children. */
-    getBlock: (id: string) => Block | undefined;
-    /** Find the sibling block before the block with the given ID. */
-    getPreviousBlock: (id: string) => Block | undefined;
-    /** Find the sibling block after the block with the given ID. */
-    getNextBlock: (id: string) => Block | undefined;
-    /** Append blocks to the end of the document. IDs are generated automatically. */
-    appendBlocks: (...blocks: BlockInput[]) => void;
-    /** Insert blocks after the block with the given reference ID. IDs are generated automatically. */
-    insertBlocks: (referenceId: string, ...blocks: BlockInput[]) => void;
-}
-
-export declare interface BlockEditorOptions {
-    initialBlocks?: Block[];
-    readOnly?: boolean;
+export declare interface BlockEditorProps {
+    editor: YooEditor;
     placeholder?: string;
-    registry?: BlockTypeRegistry;
-    customBlocks?: BlockTypeDefinition[];
-    exclude?: string[];
-    onChangeBlocks?: (blocks: Block[]) => void;
-}
-
-export declare interface BlockEditorProps extends BoxProps {
-    controller: BlockEditorController & {
-        portalManager: PortalManager;
-    };
     autoFocus?: boolean;
     readOnly?: boolean;
-    hideGutter?: boolean;
+    className?: string;
+    onChange?: (value: YooptaContentValue, options: YooptaOnChangeOptions) => void;
+    children?: ReactNode;
 }
 
-export declare const blockHandlePluginKey: PluginKey<BlockHandleState>;
-
-declare interface BlockHandleState {
-    hoveredBlockPos: number | null;
-    hoveredBlockNode: Node_2 | null;
-    dropIndicatorPos: number | null;
-}
+export declare type BlockNode = HeadingNode | ParagraphNode | CodeNode | BlockquoteNode | ListNode | TableNode | ThematicBreakNode | DivNode | DetailsNode | ImageNode | CheckNode | RailroadDiagramNode | SurrealistMiniNode | VersionNode | SinceNode | LabelNode | TabsNode;
 
-/**
- * Input type for creating blocks via the controller API.
- * Omits `id` since IDs are generated internally.
- */
-export declare type BlockInput = Omit<Block, "id">;
+export declare type BlockOptionsComponent = FC<{
+    blockId: string;
+}>;
 
-export declare type BlockNode = HeadingNode | ParagraphNode | CodeNode | BlockquoteNode | ListNode | TableNode | ThematicBreakNode | DivNode | DetailsNode | ImageNode | CheckNode | RailroadDiagramNode | SurrealistMiniNode | VersionNode | SinceNode | LabelNode | TabsNode;
+declare type BlockquoteElementMap = {
+    blockquote: BlockquoteElement;
+};
 
 export declare interface BlockquoteNode {
     type: "blockquote";
@@ -160,128 +106,14 @@ export declare interface BlockquoteNode {
     noteTitle?: string;
 }
 
-export declare const blockquoteSpec: NodeSpec;
+export declare const BlockRenderer: FC<BlockRendererProps>;
 
-/** SSR-compatible read-only renderer for Block[] data. */
-export declare const BlockRenderer: FC<BlockRendererComponentProps>;
-
-export declare interface BlockRendererComponentProps {
-    /** The blocks to render. */
-    blocks: Block[];
-    /** Registry providing block type definitions with readOnlyRender components. */
-    registry?: BlockTypeRegistry;
-    /** Root container class name. */
-    className?: string;
-}
-
-/** Props for custom block renderers used with BlockRenderer. */
 export declare interface BlockRendererProps {
-    block: Block;
-    inlineContent?: ReactNode;
-    children?: ReactNode;
-}
-
-/** Props for read-only block rendering. */
-declare interface BlockRendererProps_2 {
-    block: Block;
-    inlineContent?: ReactNode;
-    children?: ReactNode;
-}
-
-/** Configuration for creating a block type definition without raw ProseMirror NodeSpec. */
-export declare interface BlockSpecConfig {
-    /** Unique block type identifier (hyphenated, e.g. "callout"). */
-    type: string;
-    /** Map of prop names to their defaults. Generates NodeSpec attrs automatically. */
-    propSchema?: Record<string, PropDefault>;
-    /** Content model shorthand: "inline" for text, "blocks" for nested blocks, "none" for atoms. */
-    content?: "inline" | "blocks" | "none";
-    /** React component for rendering this block in the editor. */
-    render?: FC<ReactNodeViewProps>;
-    /** Slash menu entry for inserting this block. */
-    slashMenuItem?: Omit<SlashMenuItem, "type">;
-    /** Raw NodeSpec overrides for advanced use cases. Merged after generated spec. */
-    nodeSpecOverrides?: Partial<NodeSpec>;
-}
-
-/** Convert a Block[] JSON model to a ProseMirror document node. */
-export declare function blocksToDoc(blocks: Block[], schema: Schema): Node_2;
-
-/** Convert a single Block to a ProseMirror blockContainer node. */
-export declare function blockToNode(block: Block, schema: Schema): Node_2;
-
-/** Identifies the type of a block in the editor document. Extensible via string. */
-export declare type BlockType = "text" | "list-item" | "checklist-item" | "blockquote" | "table" | "table-row" | "table-cell" | "columns" | "column" | "divider" | "collapsible-item" | "code-block" | (string & {});
-
-/**
- * Defines a block type that can be registered with a BlockTypeRegistry.
- * Includes the ProseMirror NodeSpec, optional React component for
- * rendering, slash menu entry, input rule, and behavior declarations.
- */
-export declare interface BlockTypeDefinition {
-    type: string;
-    /** ProseMirror node name. Defaults to `type` if not specified. */
-    nodeName?: string;
-    nodeSpec: NodeSpec;
-    /** React component for rendering this block via NodeView. */
-    component?: FC<ReactNodeViewProps>;
-    /** Whether the NodeView should be non-editable (atom). */
-    atom?: boolean;
-    /** Slash menu entries for inserting this block. */
-    slashMenuItems?: SlashMenuItem[];
-    /** Input rules for markdown-style shortcuts. */
-    inputRules?: InputRule[];
-    /**
-     * Factory to create ProseMirror node(s) when this block is inserted
-     * via the slash menu. Returns a blockContainer node.
-     */
-    createNode?: (schema: Schema) => Node_2;
-    /** Declares list-like enter/backspace behavior. */
-    listBehavior?: ListBehavior;
-    /** When true, the Enter key is not handled (falls through to ProseMirror default). */
-    enterPassthrough?: boolean;
-    /** Extract Block.props from a ProseMirror node (doc -> JSON conversion). */
-    toBlockProps?: (node: Node_2) => Record<string, unknown>;
-    /** Convert Block.props to ProseMirror node attrs (JSON -> doc conversion). */
-    fromBlockProps?: (props: Record<string, unknown>) => Record<string, unknown>;
-    /** Custom logic for converting a Block to a ProseMirror inner node. */
-    createInnerNode?: (block: Block, schema: Schema) => Node_2;
-    /** Whether this block has inline text content. Auto-detected from nodeSpec if not set. */
-    hasInlineContent?: boolean;
-    /** Whether this block renders children inside itself (e.g. blockquote, table, columns). */
-    isContainerBlock?: boolean;
-    /** Label shown in the toolbar's block type dropdown. */
-    toolbarLabel?: string | ((node: Node_2) => string);
-    /** Options for the toolbar's block type conversion dropdown. */
-    toolbarOptions?: {
-        label: string;
-        attrs?: Record<string, unknown>;
-    }[];
-    /** React component for rendering this block in read-only mode. */
-    readOnlyRender?: FC<BlockRendererProps_2>;
-}
-
-/**
- * Registry for block types. Register definitions before
- * passing to `useBlockEditor` so the schema, slash menu, and
- * node views are extended automatically.
- */
-export declare class BlockTypeRegistry {
-    private definitions;
-    /** Register a block type definition. */
-    register(definition: BlockTypeDefinition): void;
-    /** Look up a registered definition by block type name. */
-    get(type: string): BlockTypeDefinition | undefined;
-    /** Look up a registered definition by ProseMirror node name. */
-    getByNodeName(nodeName: string): BlockTypeDefinition | undefined;
-    /** Return all registered definitions. */
-    getAll(): BlockTypeDefinition[];
-    /** Collect ProseMirror NodeSpecs from all registered definitions. */
-    getNodeSpecs(): Record<string, NodeSpec>;
-    /** Collect slash menu items from all registered definitions. */
-    getSlashMenuItems(): SlashMenuItem[];
-    /** Collect input rules from all registered definitions. */
-    getInputRules(): InputRule[];
+    value: YooptaContentValue;
+    marks?: YooptaMark<any>[];
+    plugins?: YooptaPlugin<Record<string, SlateElement>, Record<string, unknown>>[];
+    withHeadingLinks?: boolean;
+    className?: string;
 }
 
 export declare interface BooleanHandle {
@@ -405,6 +237,41 @@ export declare const brandRuby: string;
 
 export declare const brandRust: string;
 
+export declare const BRANDSAFE_BASE = "https://cdn.brandsafe.io";
+
+export declare const BrandsafeImage: YooptaPlugin<BrandsafeImageElementMap>;
+
+export declare type BrandsafeImageElement = SlateElement<"brandsafe-image", BrandsafeImageProps>;
+
+export declare type BrandsafeImageElementMap = {
+    "brandsafe-image": BrandsafeImageElement;
+};
+
+export declare interface BrandsafeImageProps {
+    nodeType: "void";
+    code: string;
+}
+
+export declare const BrandsafeVideo: YooptaPlugin<BrandsafeVideoElementMap>;
+
+export declare type BrandsafeVideoElement = SlateElement<"brandsafe-video", BrandsafeVideoProps>;
+
+export declare type BrandsafeVideoElementMap = {
+    "brandsafe-video": BrandsafeVideoElement;
+};
+
+export declare type BrandsafeVideoFormat = "mp4" | "webm" | "mov";
+
+export declare interface BrandsafeVideoProps {
+    nodeType: "void";
+    code: string;
+    format: BrandsafeVideoFormat;
+    loop: boolean;
+    autoplay: boolean;
+    muted: boolean;
+    controls: boolean;
+}
+
 export declare const brandSamsung: string;
 
 export declare const brandSiteForge: string;
@@ -452,19 +319,8 @@ export declare interface BreakNode {
     style?: string;
 }
 
-/**
- * Build a ProseMirror Schema from the registry's block type definitions.
- * The registry must already have all desired block types registered.
- * Use `customMarks` to add custom mark specs alongside the built-in ones.
- */
-export declare function buildSchema(registry?: BlockTypeRegistry, _exclude?: string[], customMarks?: Record<string, MarkSpec>): Schema;
-
-export declare const builtInMarks: Record<string, MarkSpec>;
-
 export declare function Check({ children, ...props }: CheckProps): ReactNode;
 
-export declare const checklistItemSpec: NodeSpec;
-
 export declare interface CheckNode {
     type: "check";
     children: InlineNode[];
@@ -499,8 +355,6 @@ export declare interface CodeBlockProps extends Omit<PaperProps, "children" | "s
     withLineNumbers?: boolean;
 }
 
-export declare const codeBlockSpec: NodeSpec;
-
 export declare const CodeEditor: FC<CodeEditorProps>;
 
 export declare interface CodeEditorProps extends BoxProps {
@@ -522,16 +376,12 @@ export declare interface CodeNode {
     style?: string;
 }
 
-export declare const collapsibleItemSpec: NodeSpec;
+export declare const COLOR_OPTIONS: OptionItem[];
 
 export declare type ColorScheme = keyof ThemeConfig;
 
 declare type ColorScheme_2 = keyof ThemeConfig_2;
 
-export declare const columnSpec: NodeSpec;
-
-export declare const columnsSpec: NodeSpec;
-
 declare interface CommentNode {
     type: "Comment";
     text: string;
@@ -555,57 +405,11 @@ declare type ComponentMap = {
     [T in AnyNode["type"]]: ComponentFunction<T>;
 };
 
-/**
- * Factory function to create a BlockEditorController from refs.
- * Used internally by `useBlockEditor`.
- */
-export declare function createBlockEditorController(ref: Ref<HTMLDivElement | null>, editorViewRef: RefObject<EditorView_2 | null>, mountedRef: {
-    current: boolean;
-}): BlockEditorController;
-
-/**
- * Create a BlockTypeDefinition from a simplified config.
- * Generates `nodeSpec` (including `parseDOM`/`toDOM`) automatically from `propSchema`.
- * The raw `nodeSpec` field on `BlockTypeDefinition` remains available via `nodeSpecOverrides`.
- */
-export declare function createBlockSpec(config: BlockSpecConfig): BlockTypeDefinition;
-
 /**
  * Create a style highlighter for the given color scheme and syntax theme
  */
 export declare function createHighlighter(colorScheme: MantineColorScheme): Highlighter;
 
-/**
- * Create an InlineContentDefinition from a simplified config.
- * Generates a ProseMirror inline node spec with appropriate attrs and DOM serialization.
- */
-export declare function createInlineContentSpec(config: InlineContentSpecConfig): InlineContentDefinition;
-
-export declare function createMarkKeymap(schema: Schema): Record<string, Command_2>;
-
-/**
- * Create a ProseMirror NodeViewConstructor that renders a React
- * component via the PortalManager. The component receives
- * `ReactNodeViewProps` and can use `contentRef` to mark its
- * editable content area.
- *
- * **Focus resolution:** When a new NodeView is created and the
- * ProseMirror selection falls inside it, `contentDOM` is already
- * in the DOM tree so ProseMirror can sync its cursor. After React
- * renders the portal, `contentRef` re-parents `contentDOM` and
- * re-syncs the DOM selection automatically.
- *
- * **`data-focus` convention:** For blocks that need custom focus
- * behavior (e.g. atom blocks wrapping a `<CodeEditor>`), add a
- * `data-focus` attribute to the element that should receive DOM
- * focus. After React renders, the NodeView will call `.focus()`
- * on the first `[data-focus]` element if the ProseMirror selection
- * is inside this block.
- */
-export declare function createReactNodeView(Component: FC<ReactNodeViewProps>, options?: {
-    contentEditable?: boolean;
-}): NodeViewConstructor;
-
 /**
  * Create a new serialized editor state from a document string.
  *
@@ -619,12 +423,32 @@ export declare function createSerializedState(doc: string): EditorStateSnapshot;
  */
 export declare function createStyleHighlighter(theme: ThemeConfig_2, colorScheme: ColorScheme_2): Highlighter;
 
+export declare const CUSTOM_BLOCKS: Set<string>;
+
 /**
  * A custom variant of the history keymap that uses
  * the Mod key instead of the Ctrl key
  */
 export declare const customHistoryKeymap: readonly KeyBinding[];
 
+export declare const DEFAULT_BLOCK_MARKS: YooptaMark<any>[];
+
+export declare const DEFAULT_BLOCK_PLUGINS: YooptaPlugin<Record<string, SlateElement>, Record<string, unknown>>[];
+
+export declare const DEFAULT_BUTTON_PROPS: MantineButtonProps;
+
+export declare const DEFAULT_CODEBLOCK_PROPS: SurrealCodeBlockProps;
+
+export declare const DEFAULT_IMAGE_PROPS: BrandsafeImageProps;
+
+export declare const DEFAULT_LINK_PROPS: SurrealLinkProps;
+
+export declare const DEFAULT_TABLE_PROPS: MantineTableProps;
+
+export declare const DEFAULT_VIDEO_EMBED_PROPS: VideoEmbedProps;
+
+export declare const DEFAULT_VIDEO_PROPS: BrandsafeVideoProps;
+
 export declare type DefaultSort = {
     [key: string]: unknown;
 };
@@ -655,8 +479,6 @@ export declare interface DiagramNode {
     children: RailroadNode[];
 }
 
-export declare const dividerSpec: NodeSpec;
-
 export declare interface DivNode {
     type: "div";
     children: BlockNode[];
@@ -665,9 +487,6 @@ export declare interface DivNode {
     style?: string;
 }
 
-/** Convert a ProseMirror document node to a Block[] JSON model. */
-export declare function docToBlocks(doc: Node_2): Block[];
-
 export declare interface EditorController {
     ref: RefObject<HTMLDivElement | null>;
     mounted: boolean;
@@ -715,8 +534,6 @@ export declare interface EmphasisNode {
  */
 export declare function enterNode(state: ParserState, nodeType: string, node: BlockNode | SummaryNode): void;
 
-export declare function executeSlashCommand(view: EditorView_2, schema: Schema, menuState: SlashMenuState, item: SlashMenuItem): void;
-
 /**
  * Exit a node (pop from stack and validate)
  */
@@ -733,35 +550,6 @@ export declare interface ExtractedCode {
  */
 export declare function extractTest(input: string): ExtractedCode;
 
-export declare function filterItems(items: SlashMenuItem[], query: string): SlashMenuItem[];
-
-/**
- * Walk up from a resolved position to find the nearest ancestor
- * node matching the given type name.
- *
- * @returns The ancestor's absolute position, depth, and node, or null if not found.
- */
-export declare function findAncestor($pos: ResolvedPos, typeName: string): {
-    pos: number;
-    depth: number;
-    node: Node_2;
-} | null;
-
-/** Find the position and node of a blockContainer by its ID attribute. */
-export declare function findBlockPos(doc: Node_2, id: string): {
-    pos: number;
-    node: Node_2;
-} | undefined;
-
-/**
- * Find the nearest blockContainer ancestor's position from a
- * resolved position.
- */
-export declare function findContainerPos($pos: ResolvedPos): number | null;
-
-/** Convert a ProseMirror inline Fragment to an InlineContent[] array. */
-export declare function fragmentToInline(fragment: Fragment): InlineContent[];
-
 /**
  * Generate a 24-character hex string suitable for use as a
  * stable block identifier. Uses `crypto.getRandomValues` for
@@ -769,6 +557,14 @@ export declare function fragmentToInline(fragment: Fragment): InlineContent[];
  */
 export declare function generateRandomId(): string;
 
+export declare function getBlockOptionsComponent(blockType: string): BlockOptionsComponent | undefined;
+
+export declare function getBrandsafeImageURL(imageId: string | undefined, width?: number, quality?: number): string | undefined;
+
+export declare function getBrandsafeVideoURL(videoId: string | undefined, format?: "mp4" | "webm" | "mov", controls?: boolean): string | undefined;
+
+export declare const HeadingLinksProvider: React.Provider<boolean>;
+
 export declare interface HeadingNode {
     type: "heading";
     depth: 1 | 2 | 3 | 4 | 5 | 6;
@@ -1156,51 +952,7 @@ export declare interface InlineCodeNode {
     style?: string;
 }
 
-/** A piece of inline content within a block, either styled text, a link, or custom inline content. */
-export declare type InlineContent = {
-    type: "text";
-    text: string;
-    styles?: TextStyles;
-} | {
-    type: "link";
-    href: string;
-    content: InlineContent[];
-} | {
-    type: string;
-    props: Record<string, unknown>;
-};
-
-/** Definition of a custom inline content type. */
-export declare interface InlineContentDefinition {
-    type: string;
-    nodeSpec: NodeSpec;
-    component: FC<ReactNodeViewProps>;
-    triggerCharacter?: string;
-}
-
-/** Configuration for creating a custom inline content type. */
-export declare interface InlineContentSpecConfig {
-    /** Unique type identifier for this inline content. */
-    type: string;
-    /** Map of prop names to their defaults. */
-    propSchema?: Record<string, InlinePropDefault>;
-    /** Whether this inline content contains styled text ("styled") or not ("none"). */
-    content?: "styled" | "none";
-    /** React component for rendering this inline content. */
-    render: FC<ReactNodeViewProps>;
-    /** Character that triggers a suggestion menu for inserting this inline content (e.g. "@"). */
-    triggerCharacter?: string;
-}
-
-export declare type InlineNode = TextNode | LinkNode | InlineCodeNode | StrongNode | EmphasisNode | BreakNode | ImageNode;
-
-/** Schema for a single inline content prop with a default value. */
-export declare interface InlinePropDefault {
-    default: string | number | boolean;
-}
-
-/** Convert an InlineContent[] array to a ProseMirror inline Fragment. */
-export declare function inlineToFragment(content: InlineContent[], schema: Schema): Fragment;
+export declare type InlineNode = TextNode | LinkNode | InlineCodeNode | StrongNode | EmphasisNode | BreakNode | SpanNode | ImageNode;
 
 /**
  * Check if a code point is an emoji
@@ -1239,14 +991,6 @@ export declare interface LinkNode {
     style?: string;
 }
 
-/** Declares list-like enter/backspace behavior for a block type. */
-export declare interface ListBehavior {
-    /** Create a new sibling node when Enter is pressed. */
-    createSibling: (schema: Schema) => Node_2;
-    /** Text prefix to insert when backspacing an empty item back to text. */
-    backspacePrefix?: string;
-}
-
 export declare interface ListItemNode {
     type: "listItem";
     checked?: boolean;
@@ -1257,8 +1001,6 @@ export declare interface ListItemNode {
     style?: string;
 }
 
-export declare const listItemSpec: NodeSpec;
-
 export declare interface ListNode {
     type: "list";
     variant?: "ordered" | "unordered" | "checklist";
@@ -1275,7 +1017,49 @@ export declare interface ListNode {
  */
 export declare const MANTINE_THEME: MantineThemeOverride;
 
-export declare function markActive(state: EditorState, type: MarkType): boolean;
+export declare const MantineBlockquote: YooptaPlugin<BlockquoteElementMap, Record<string, unknown>>;
+
+export declare const MantineButton: YooptaPlugin<MantineButtonElementMap>;
+
+export declare type MantineButtonElement = SlateElement<"mantine-button", MantineButtonProps>;
+
+export declare type MantineButtonElementMap = {
+    "mantine-button": MantineButtonElement;
+};
+
+export declare interface MantineButtonProps {
+    nodeType: "void";
+    label: string;
+    url: string;
+    variant: ButtonProps["variant"];
+    color: MantineColor;
+    size: MantineSize;
+    radius: MantineSize;
+    fullWidth: boolean;
+}
+
+export declare const MantineCallout: YooptaPlugin<CalloutElementMap, Record<string, unknown>>;
+
+export declare const MantineChecklist: YooptaPlugin<Pick<ListElementMap, "todo-list">, Record<string, unknown>>;
+
+export declare const MantineDivider: YooptaPlugin<DividerElementMap, Record<string, unknown>>;
+
+export declare const MantineTable: YooptaPlugin<MantineTableElementMap>;
+
+export declare type MantineTableElement = SlateElement<"mantine-table", MantineTableProps>;
+
+export declare type MantineTableElementMap = {
+    "mantine-table": MantineTableElement;
+};
+
+export declare interface MantineTableProps {
+    nodeType: "void";
+    rows: string[][];
+    withHeaderRow: boolean;
+    striped: boolean;
+    highlightOnHover: boolean;
+    caption: string;
+}
 
 /**
  * Main Markdown component that parses markdown and renders it
@@ -1352,6 +1136,8 @@ declare type NodeOfType<T extends AnyNode["type"]> = Extract<AnyNode, {
     type: T;
 }>;
 
+export declare const NON_TEXT_BLOCKS: Set<string>;
+
 declare interface NonTerminalNode {
     type: "NonTerminal";
     text: string;
@@ -1384,6 +1170,11 @@ declare interface OptionalNode {
     child: RailroadNode;
 }
 
+declare type OptionItem = {
+    label: string;
+    value: string;
+};
+
 export declare interface ParagraphNode {
     type: "paragraph";
     children: InlineNode[];
@@ -1429,7 +1220,7 @@ export declare function parseHtmlTable(state: ParserState, attrs: Record<string,
 export declare function parseHtmlTag(state: ParserState): void;
 
 export declare function parseHtmlTagInline(text: string, startIndex: number): {
-    node: BreakNode;
+    node: BreakNode | SpanNode;
     endIndex: number;
 } | null;
 
@@ -1947,40 +1738,6 @@ export declare const pictoZed: string;
 
 export declare const pictoZoomIn: string;
 
-declare interface PortalEntry {
-    key: string;
-    component: ReactNode;
-    container: HTMLElement;
-}
-
-declare type PortalListener = () => void;
-
-/**
- * Manages React portals for ProseMirror NodeViews. Coordinates
- * between ProseMirror's synchronous DOM lifecycle and React's
- * async rendering via a portal registry and subscription model.
- */
-export declare class PortalManager {
-    private portals;
-    private listeners;
-    private cachedEntries;
-    register(entry: PortalEntry): void;
-    update(key: string, component: ReactNode): void;
-    remove(key: string): void;
-    getEntries(): PortalEntry[];
-    subscribe(listener: PortalListener): () => void;
-    private invalidate;
-}
-
-export declare function PortalOutlet({ manager }: {
-    manager: PortalManager;
-}): ReactNode;
-
-export declare function PortalProvider({ manager, children, }: {
-    manager: PortalManager;
-    children: ReactNode;
-}): ReactNode;
-
 /**
  * Process highlight regions in code
  */
@@ -1989,11 +1746,6 @@ export declare function processHighlightRegions(code: string): {
     processedCode: string;
 };
 
-/** Schema for a single block prop with a default value. */
-export declare interface PropDefault {
-    default: string | number | boolean;
-}
-
 /**
  * Validate and process code attributes
  */
@@ -2032,16 +1784,6 @@ export declare interface RailroadDiagramProps extends BoxProps {
 
 export declare type RailroadNode = DiagramNode | SequenceNode | TerminalNode | NonTerminalNode | OptionalNode | ChoiceNode | OneOrMoreNode | ZeroOrMoreNode | CommentNode;
 
-/** Props passed to React components rendered inside ProseMirror NodeViews. */
-export declare interface ReactNodeViewProps {
-    node: Node_2;
-    view: EditorView_2;
-    getPos: () => number | undefined;
-    contentRef: (element: HTMLElement | null) => void;
-    selected: boolean;
-    updateAttrs: (attrs: Record<string, unknown>) => void;
-}
-
 /**
  * Read tag name from HTML tag starting at index
  * Returns tag name and end index
@@ -2051,16 +1793,7 @@ export declare function readTagName(text: string, startIndex: number): {
     endIndex: number;
 };
 
-/**
- * Register all built-in block type definitions with the registry and
- * return the fully-built ProseMirror Schema.
- *
- * Performs a two-phase bootstrap:
- * 1. Registers nodeSpecs using a minimal stub schema (no input rules)
- * 2. Builds the real schema from the registry, then re-registers
- *    definitions with proper input rules that reference real node types.
- */
-export declare function registerBuiltInBlocks(registry: BlockTypeRegistry, exclude?: string[]): Schema;
+export declare function registerBlockOptions(blockType: string, component: BlockOptionsComponent): void;
 
 /**
  * Render parsed markdown AST to React elements
@@ -2080,8 +1813,6 @@ export declare interface RenderMarkdownProps extends StackProps {
     componentProps?: MarkdownComponentProps;
 }
 
-export declare function resolveDropPosition(view: EditorView_2, clientY: number): number | null;
-
 export declare interface Root {
     type: "root";
     children: BlockNode[];
@@ -2116,27 +1847,7 @@ export declare interface SinceProps extends Omit<BadgeProps, "children"> {
     prefix?: string;
 }
 
-/** Describes an entry in the slash command menu. */
-export declare interface SlashMenuItem {
-    type: string;
-    label: string;
-    description?: string;
-    icon?: ReactNode;
-    shortcut?: string;
-    /** Create a ProseMirror blockContainer node for this menu item. */
-    createNode?: (schema: Schema, id: string) => Node_2;
-}
-
-export declare const slashMenuPluginKey: PluginKey<SlashMenuState>;
-
-declare interface SlashMenuState {
-    open: boolean;
-    blockPos: number | null;
-    triggerPos: number;
-    query: string;
-    selectedIndex: number;
-    items: SlashMenuItem[];
-}
+export declare const SIZE_OPTIONS: OptionItem[];
 
 export declare type SortDirection = "asc" | "desc" | undefined;
 
@@ -2153,6 +1864,14 @@ export declare interface SortOptions<T = DefaultSort> {
 
 export declare const Spacer: FC<BoxProps>;
 
+export declare interface SpanNode {
+    type: "span";
+    children: InlineNode[];
+    className?: string;
+    id?: string;
+    style?: string;
+}
+
 export declare type StateFields = {
     [prop: string]: StateField<any>;
 };
@@ -2182,6 +1901,22 @@ export declare interface SummaryProps extends Omit<BoxProps, "component" | "chil
     children: ReactNode;
 }
 
+export declare const SurrealCodeBlock: YooptaPlugin<SurrealCodeBlockElementMap>;
+
+export declare type SurrealCodeBlockElement = SlateElement<"surreal-codeblock", SurrealCodeBlockProps>;
+
+export declare type SurrealCodeBlockElementMap = {
+    "surreal-codeblock": SurrealCodeBlockElement;
+};
+
+export declare interface SurrealCodeBlockProps {
+    nodeType: "void";
+    code: string;
+    language: AnyLanguage;
+    title: string;
+    withLineNumbers: boolean;
+}
+
 export declare function SurrealistMini({ config, frameRef, ...props }: SurrealistMiniProps): ReactNode;
 
 export declare interface SurrealistMiniNode {
@@ -2206,6 +1941,22 @@ export declare interface SurrealistMiniProps extends BoxProps {
     frameRef?: RefObject<HTMLIFrameElement | null>;
 }
 
+export declare const SurrealLink: YooptaPlugin<SurrealLinkElementMap>;
+
+export declare type SurrealLinkElement = SlateElement<"surreal-link", SurrealLinkProps>;
+
+export declare type SurrealLinkElementMap = {
+    "surreal-link": SurrealLinkElement;
+};
+
+export declare interface SurrealLinkProps {
+    nodeType: "inline";
+    url: string;
+    variant?: AnchorProps["variant"];
+    target?: string;
+    rel?: string;
+}
+
 export declare const SYNTAX_THEME_CONFIG: ThemeConfig;
 
 export declare interface TabItem {
@@ -2233,8 +1984,6 @@ export declare interface TableCellNode {
     isHeader: boolean;
 }
 
-export declare const tableCellSpec: NodeSpec;
-
 export declare interface TableNode {
     type: "table";
     align?: Array<"left" | "right" | "center" | null>;
@@ -2252,10 +2001,6 @@ export declare interface TableRowNode {
     style?: string;
 }
 
-export declare const tableRowSpec: NodeSpec;
-
-export declare const tableSpec: NodeSpec;
-
 export declare function Tabs({ items, syncKey, ...props }: TabsProps): ReactNode;
 
 export declare interface TabsNode {
@@ -2277,8 +2022,6 @@ declare interface TerminalNode {
     text: string;
 }
 
-export declare const textBlockSpec: NodeSpec;
-
 export declare interface TextNode {
     type: "text";
     value: string;
@@ -2287,15 +2030,6 @@ export declare interface TextNode {
     style?: string;
 }
 
-/** Rich text style flags applied to inline text content. */
-export declare interface TextStyles {
-    bold?: boolean;
-    italic?: boolean;
-    underline?: boolean;
-    strikethrough?: boolean;
-    code?: boolean;
-}
-
 export declare interface ThematicBreakNode {
     type: "thematicBreak";
     className?: string;
@@ -2325,21 +2059,7 @@ export declare const ThemedImage: FC<ThemedImageProps>;
 
 export declare interface ThemedImageProps extends ImageProps {
     darkSrc: string;
-    colorScheme?: "light" | "dark";
-}
-
-/** Map a camelCase ProseMirror node name to the hyphenated BlockType string. */
-export declare function toBlockType(nodeName: string): string;
-
-/** Map a hyphenated BlockType string to the camelCase ProseMirror node name. */
-export declare function toNodeName(blockType: string): string;
-
-export declare const toolbarPluginKey: PluginKey<ToolbarState>;
-
-declare interface ToolbarState {
-    show: boolean;
-    from: number;
-    to: number;
+    colorScheme?: "light" | "dark" | "auto";
 }
 
 /**
@@ -2347,16 +2067,6 @@ declare interface ToolbarState {
  */
 export declare type TypeVisitor<T extends AnyNode> = (node: T, index: number | undefined, parent: AnyNode | Root | null) => undefined | boolean | void;
 
-export declare function useBlockEditor(options?: BlockEditorOptions): BlockEditorController & {
-    portalManager: PortalManager;
-};
-
-/**
- * Create a memoized BlockTypeRegistry from an array of block type definitions.
- * Definitions should be module-level constants for stable references.
- */
-export declare function useBlockRegistry(definitions: BlockTypeDefinition[]): BlockTypeRegistry;
-
 export declare function useEditor(options?: EditorOptions): EditorController;
 
 /**
@@ -2393,6 +2103,8 @@ export declare function useSwitch(initialState?: boolean, callbacks?: {
     onClose?: () => void;
 }): readonly [boolean, BooleanHandle];
 
+export declare const VARIANT_OPTIONS: OptionItem[];
+
 export declare function Version({ version, ...props }: VersionProps): ReactNode;
 
 export declare interface VersionNode {
@@ -2407,6 +2119,34 @@ export declare interface VersionProps extends CodeProps {
     version: string;
 }
 
+export declare type VideoControlsPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+
+export declare const VideoEmbed: YooptaPlugin<VideoEmbedElementMap>;
+
+export declare type VideoEmbedElement = SlateElement<"video-embed", VideoEmbedProps>;
+
+export declare type VideoEmbedElementMap = {
+    "video-embed": VideoEmbedElement;
+};
+
+export declare interface VideoEmbedProps {
+    nodeType: "void";
+    url: string;
+}
+
+export declare const VideoPlayer: FC<VideoPlayerProps>;
+
+export declare interface VideoPlayerProps extends BoxProps {
+    src: string;
+    thumbnail?: string;
+    poster?: string;
+    autoPlay?: boolean;
+    loop?: boolean;
+    initialMuted?: boolean;
+    controlsPosition?: VideoControlsPosition;
+    videoProps?: Omit<VideoHTMLAttributes<HTMLVideoElement>, "autoPlay" | "loop" | "poster" | "controls" | "src" | "muted">;
+}
+
 /**
  * Visit all nodes in the tree
  */