@blocknote/core 0.38.0 → 0.39.1-capitol

package/types/src/blocks/defaultProps.d.ts

@@ -1,3 +1,4 @@
+import { Attribute } from "@tiptap/core";
 import type { Props } from "../schema/index.js";
 export declare const defaultProps: {
     backgroundColor: {
@@ -12,4 +13,19 @@ export declare const defaultProps: {
     };
 };
 export type DefaultProps = Props<typeof defaultProps>;
-export declare const inheritedProps: string[];
+export declare const parseDefaultProps: (element: HTMLElement) => Partial<Props<{
+    backgroundColor: {
+        default: "default";
+    };
+    textColor: {
+        default: "default";
+    };
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+}>>;
+export declare const addDefaultPropsExternalHTML: (props: Partial<DefaultProps>, element: HTMLElement) => void;
+export declare const getBackgroundColorAttribute: (attributeName?: string) => Attribute;
+export declare const getTextColorAttribute: (attributeName?: string) => Attribute;
+export declare const getTextAlignmentAttribute: (attributeName?: string) => Attribute;

package/types/src/blocks/index.d.ts

@@ -0,0 +1,24 @@
+export * from "./Audio/block.js";
+export * from "./Audio/parseAudioElement.js";
+export * from "./Code/block.js";
+export * from "./File/block.js";
+export * from "./Heading/block.js";
+export * from "./Image/block.js";
+export * from "./ListItem/BulletListItem/block.js";
+export * from "./ListItem/CheckListItem/block.js";
+export * from "./ListItem/NumberedListItem/block.js";
+export * from "./ListItem/ToggleListItem/block.js";
+export * from "./PageBreak/block.js";
+export * from "./Paragraph/block.js";
+export * from "./Quote/block.js";
+export * from "./Table/block.js";
+export * from "./Video/block.js";
+export { EMPTY_CELL_HEIGHT, EMPTY_CELL_WIDTH } from "./Table/TableExtension.js";
+export * from "./ToggleWrapper/createToggleWrapper.js";
+export * from "./File/helpers/uploadToTmpFilesDotOrg_DEV_ONLY.js";
+export * from "./PageBreak/getPageBreakSlashMenuItems.js";
+export * from "./BlockNoteSchema.js";
+export * from "./defaultBlockHelpers.js";
+export * from "./defaultBlocks.js";
+export * from "./defaultBlockTypeGuards.js";
+export * from "./defaultProps.js";

package/types/src/blocks/utils/listItemEnterHandler.d.ts

@@ -0,0 +1,2 @@
+import { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
+export declare const handleEnter: (editor: BlockNoteEditor<any, any, any>, listItemType: string) => boolean;

package/types/src/editor/BlockNoteEditor.d.ts

@@ -1,7 +1,10 @@
-import { AnyExtension, EditorOptions } from "@tiptap/core";
+import { AnyExtension, EditorOptions, Editor as TiptapEditor } from "@tiptap/core";
+import { type Command, type Plugin, type Transaction } from "@tiptap/pm/state";
 import { Node, Schema } from "prosemirror-model";
 import * as Y from "yjs";
-import { Block, DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, PartialBlock } from "../blocks/defaultBlocks.js";
+import { BlocksChanged } from "../api/getBlocksChangedByTransaction.js";
+import type { ThreadStore, User } from "../comments/index.js";
+import type { ForkYDocPlugin } from "../extensions/Collaboration/ForkYDocPlugin.js";
 import type { CommentsPlugin } from "../extensions/Comments/CommentsPlugin.js";
 import { FilePanelProsemirrorPlugin } from "../extensions/FilePanel/FilePanelPlugin.js";
 import { FormattingToolbarProsemirrorPlugin } from "../extensions/FormattingToolbar/FormattingToolbarPlugin.js";
@@ -9,21 +12,15 @@ import { LinkToolbarProsemirrorPlugin } from "../extensions/LinkToolbar/LinkTool
 import { SideMenuProsemirrorPlugin } from "../extensions/SideMenu/SideMenuPlugin.js";
 import { SuggestionMenuProseMirrorPlugin } from "../extensions/SuggestionMenu/SuggestionPlugin.js";
 import { TableHandlesProsemirrorPlugin } from "../extensions/TableHandles/TableHandlesPlugin.js";
-import { BlockIdentifier, BlockNoteDOMAttributes, BlockSchema, BlockSpecs, InlineContentSchema, InlineContentSpecs, PartialInlineContent, Styles, StyleSchema, StyleSpecs } from "../schema/index.js";
-import { NoInfer } from "../util/typescript.js";
-import { TextCursorPosition } from "./cursorPositionTypes.js";
-import { Selection } from "./selectionTypes.js";
-import { BlockNoteSchema } from "./BlockNoteSchema.js";
-import { BlockNoteTipTapEditor } from "./BlockNoteTipTapEditor.js";
 import { Dictionary } from "../i18n/dictionary.js";
-import { type Command, type Plugin, type Transaction } from "@tiptap/pm/state";
-import { EditorView } from "prosemirror-view";
-import { BlocksChanged } from "../api/getBlocksChangedByTransaction.js";
-import { CodeBlockOptions } from "../blocks/CodeBlockContent/CodeBlockContent.js";
-import type { ThreadStore, User } from "../comments/index.js";
-import type { ForkYDocPlugin } from "../extensions/Collaboration/ForkYDocPlugin.js";
+import { BlockIdentifier, BlockNoteDOMAttributes, BlockSchema, BlockSpecs, CustomBlockNoteSchema, InlineContentSchema, InlineContentSpecs, PartialInlineContent, Styles, StyleSchema, StyleSpecs } from "../schema/index.js";
+import "../style.css";
 import { EventEmitter } from "../util/EventEmitter.js";
+import { NoInfer } from "../util/typescript.js";
 import { BlockNoteExtension } from "./BlockNoteExtension.js";
+import { TextCursorPosition } from "./cursorPositionTypes.js";
+import { Selection } from "./selectionTypes.js";
+import { Block, BlockNoteSchema, DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, PartialBlock } from "../blocks/index.js";
 import "../style.css";
 /**
  * A factory function that returns a BlockNoteExtension
@@ -77,10 +74,6 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends
          */
         showCursorLabels?: "always" | "activity";
     };
-    /**
-     * Options for code blocks.
-     */
-    codeBlock?: CodeBlockOptions;
     /**
      * Configuration for the comments feature, requires a `threadStore`.
      *
@@ -130,17 +123,6 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends
         width?: number;
         class?: string;
     }) => Plugin;
-    /**
-     * Configuration for headings
-     */
-    heading?: {
-        /**
-         * The levels of headings that should be available in the editor.
-         * @note Configurable up to 6 levels of headings.
-         * @default [1, 2, 3]
-         */
-        levels?: (1 | 2 | 3 | 4 | 5 | 6)[];
-    };
     /**
      * The content that should be in the editor when it's created, represented as an array of {@link PartialBlock} objects.
      *
@@ -171,7 +153,7 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends
      */
     pasteHandler?: (context: {
         event: ClipboardEvent;
-        editor: BlockNoteEditor<BSchema, ISchema, SSchema>;
+        editor: BlockNoteEditor<NoInfer<BSchema>, NoInfer<ISchema>, NoInfer<SSchema>>;
         /**
          * The default paste handler
          * @param context The context object
@@ -208,7 +190,7 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends
      * See [Custom Schemas](https://www.blocknotejs.org/docs/custom-schemas) for more info.
      * @remarks `BlockNoteSchema`
      */
-    schema: BlockNoteSchema<BSchema, ISchema, SSchema>;
+    schema: CustomBlockNoteSchema<BSchema, ISchema, SSchema>;
     /**
      * A flag indicating whether to set an HTML ID for every block
      *
@@ -296,23 +278,16 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends
     /**
      * Register extensions to the editor.
      *
-     * @internal
-     */
-    extensions?: Array<BlockNoteExtension | BlockNoteExtensionFactory>;
-    /**
-     * Boolean indicating whether the editor is in headless mode.
-     * Headless mode means we can use features like importing / exporting blocks,
-     * but there's no underlying editor (UI) instantiated.
+     * See [Extensions](/docs/features/extensions) for more info.
      *
-     * You probably don't need to set this manually, but use the `server-util` package instead that uses this option internally
-     * @internal
+     * @remarks `BlockNoteExtension[]`
      */
-    _headless?: boolean;
+    extensions?: Array<BlockNoteExtension | BlockNoteExtensionFactory>;
 };
 export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema> extends EventEmitter<{
     create: void;
 }> {
-    protected readonly options: Partial<BlockNoteEditorOptions<any, any, any>>;
+    protected readonly options: Partial<BlockNoteEditorOptions<BSchema, ISchema, SSchema>>;
     /**
      * The underlying prosemirror schema
      */
@@ -321,16 +296,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * extensions that are added to the editor, can be tiptap extensions or prosemirror plugins
      */
     extensions: Record<string, SupportedExtension>;
-    /**
-     * Boolean indicating whether the editor is in headless mode.
-     * Headless mode means we can use features like importing / exporting blocks,
-     * but there's no underlying editor (UI) instantiated.
-     *
-     * You probably don't need to set this manually, but use the `server-util` package instead that uses this option internally
-     */
-    readonly headless: boolean;
-    readonly _tiptapEditor: Omit<BlockNoteTipTapEditor, "view"> & {
-        view: EditorView | undefined;
+    readonly _tiptapEditor: TiptapEditor & {
         contentComponent: any;
     };
     /**
@@ -351,7 +317,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
     /**
      * The schema of the editor. The schema defines which Blocks, InlineContent, and Styles are available in the editor.
      */
-    readonly schema: BlockNoteSchema<BSchema, ISchema, SSchema>;
+    readonly schema: CustomBlockNoteSchema<BSchema, ISchema, SSchema>;
     readonly blockImplementations: BlockSpecs;
     readonly inlineContentImplementations: InlineContentSpecs;
     readonly styleImplementations: StyleSpecs;
@@ -391,13 +357,11 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
             cellTextColor: boolean;
             headers: boolean;
         };
-        codeBlock: CodeBlockOptions;
-        heading: {
-            levels: (1 | 2 | 3 | 4 | 5 | 6)[];
-        };
     };
-    static create<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema>(options?: Partial<BlockNoteEditorOptions<BSchema, ISchema, SSchema>>): BlockNoteEditor<BSchema, ISchema, SSchema>;
-    protected constructor(options: Partial<BlockNoteEditorOptions<any, any, any>>);
+    static create<Options extends Partial<BlockNoteEditorOptions<any, any, any>> | undefined>(options?: Options): Options extends {
+        schema: CustomBlockNoteSchema<infer BSchema, infer ISchema, infer SSchema>;
+    } ? BlockNoteEditor<BSchema, ISchema, SSchema> : BlockNoteEditor<DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema>;
+    protected constructor(options: Partial<BlockNoteEditorOptions<BSchema, ISchema, SSchema>>);
     /**
      * Stores the currently active transaction, which is the accumulated transaction from all {@link dispatch} calls during a {@link transact} calls
      */
@@ -465,11 +429,15 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
         new (...args: any[]): T;
     } & typeof BlockNoteExtension, key?: string): T;
     /**
-     * Mount the editor to a parent DOM element. Call mount(undefined) to clean up
+     * Mount the editor to a DOM element.
      *
      * @warning Not needed to call manually when using React, use BlockNoteView to take care of mounting
      */
-    mount: (parentElement?: HTMLElement | null, contentComponent?: any) => void;
+    mount: (element: HTMLElement) => void;
+    /**
+     * Unmount the editor from the DOM element it is bound to
+     */
+    unmount: () => void;
     /**
      * Get the underlying prosemirror state
      * @note Prefer using `editor.transact` to read the current editor state, as that will ensure the state is up to date
@@ -480,9 +448,10 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * Get the underlying prosemirror view
      * @see https://prosemirror.net/docs/ref/#view.EditorView
      */
-    get prosemirrorView(): EditorView | undefined;
+    get prosemirrorView(): import("prosemirror-view").EditorView;
     get domElement(): HTMLDivElement | undefined;
     isFocused(): boolean;
+    get headless(): boolean;
     focus(): void;
     onUploadStart(callback: (blockId?: string) => void): () => void;
     onUploadEnd(callback: (blockId?: string) => void): () => void;
@@ -577,7 +546,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * only the part of the block that is included in the selection.
      */
     getSelectionCutBlocks(): {
-        blocks: Block<Record<string, import("../index.js").BlockConfig>, InlineContentSchema, StyleSchema>[];
+        blocks: Block<Record<string, import("../index.js").BlockConfig<string, import("../index.js").PropSchema, "inline" | "none" | "table">>, InlineContentSchema, StyleSchema>[];
         blockCutAtStart: string | undefined;
         blockCutAtEnd: string | undefined;
         _meta: {
@@ -622,7 +591,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * Removes existing blocks from the editor. Throws an error if any of the blocks could not be found.
      * @param blocksToRemove An array of identifiers for existing blocks that should be removed.
      */
-    removeBlocks(blocksToRemove: BlockIdentifier[]): Block<Record<string, import("../index.js").BlockConfig>, InlineContentSchema, StyleSchema>[];
+    removeBlocks(blocksToRemove: BlockIdentifier[]): Block<Record<string, import("../index.js").BlockConfig<string, import("../index.js").PropSchema, "inline" | "none" | "table">>, InlineContentSchema, StyleSchema>[];
     /**
      * Replaces existing blocks in the editor with new blocks. If the blocks that should be removed are not adjacent or
      * are at different nesting levels, `blocksToInsert` will be inserted at the position of the first block in
@@ -781,14 +750,14 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
          * Returns the blocks that were inserted, updated, or deleted by the change that occurred.
          */
         getChanges(): BlocksChanged<BSchema, ISchema, SSchema>;
-    }) => void): (() => void) | undefined;
+    }) => void): () => void;
     /**
      * A callback function that runs whenever the text cursor position or selection changes.
      *
      * @param callback The callback to execute.
      * @returns A function to remove the callback.
      */
-    onSelectionChange(callback: (editor: BlockNoteEditor<BSchema, ISchema, SSchema>) => void, includeSelectionChangedByRemote?: boolean): (() => void) | undefined;
+    onSelectionChange(callback: (editor: BlockNoteEditor<BSchema, ISchema, SSchema>) => void, includeSelectionChangedByRemote?: boolean): () => void;
     /**
      * A callback function that runs when the editor has been initialized.
      *
@@ -813,7 +782,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * Paste text into the editor. Defaults to interpreting text as markdown.
      * @param text The text to paste.
      */
-    pasteText(text: string): boolean | undefined;
+    pasteText(text: string): boolean;
     /**
      * Paste markdown into the editor.
      * @param markdown The markdown to paste.

package/types/src/editor/BlockNoteExtension.d.ts

@@ -1,9 +1,76 @@
 import { Plugin } from "prosemirror-state";
 import { EventEmitter } from "../util/EventEmitter.js";
+import { AnyExtension } from "@tiptap/core";
+import { BlockSchema, InlineContentSchema, PartialBlockNoDefaults, StyleSchema } from "../schema/index.js";
+import { BlockNoteEditor } from "./BlockNoteEditor.js";
 export declare abstract class BlockNoteExtension<TEvent extends Record<string, any> = any> extends EventEmitter<TEvent> {
     static key(): string;
     protected addProsemirrorPlugin(plugin: Plugin): void;
     readonly plugins: Plugin[];
     get priority(): number | undefined;
     constructor(..._args: any[]);
+    /**
+     * Input rules for the block
+     */
+    inputRules?: InputRule[];
+    /**
+     * A mapping of a keyboard shortcut to a function that will be called when the shortcut is pressed
+     *
+     * The keys are in the format:
+     * - Key names may be strings like `Shift-Ctrl-Enter`—a key identifier prefixed with zero or more modifiers
+     * - Key identifiers are based on the strings that can appear in KeyEvent.key
+     * - Use lowercase letters to refer to letter keys (or uppercase letters if you want shift to be held)
+     * - You may use `Space` as an alias for the " " name
+     * - Modifiers can be given in any order: `Shift-` (or `s-`), `Alt-` (or `a-`), `Ctrl-` (or `c-` or `Control-`) and `Cmd-` (or `m-` or `Meta-`)
+     * - For characters that are created by holding shift, the Shift- prefix is implied, and should not be added explicitly
+     * - You can use Mod- as a shorthand for Cmd- on Mac and Ctrl- on other platforms
+     *
+     * @example
+     * ```typescript
+     * keyboardShortcuts: {
+     *   "Mod-Enter": (ctx) => {  return true; },
+     *   "Shift-Ctrl-Space": (ctx) => { return true; },
+     *   "a": (ctx) => { return true; },
+     *   "Space": (ctx) => { return true; }
+     * }
+     * ```
+     */
+    keyboardShortcuts?: Record<string, (ctx: {
+        editor: BlockNoteEditor<BlockSchema, InlineContentSchema, StyleSchema>;
+    }) => boolean>;
+    tiptapExtensions?: AnyExtension[];
 }
+export type InputRule = {
+    /**
+     * The regex to match when to trigger the input rule
+     */
+    find: RegExp;
+    /**
+     * The function to call when the input rule is matched
+     * @returns undefined if the input rule should not be triggered, or an object with the type and props to update the block
+     */
+    replace: (props: {
+        /**
+         * The result of the regex match
+         */
+        match: RegExpMatchArray;
+        /**
+         * The range of the text that was matched
+         */
+        range: {
+            from: number;
+            to: number;
+        };
+        /**
+         * The editor instance
+         */
+        editor: BlockNoteEditor<any, any, any>;
+    }) => undefined | PartialBlockNoDefaults<any, any, any>;
+};
+/**
+ * This creates an instance of a BlockNoteExtension that can be used to add to a schema.
+ * It is a bit of a hack, but it works.
+ */
+export declare function createBlockNoteExtension(options: Partial<Pick<BlockNoteExtension, "inputRules" | "keyboardShortcuts" | "plugins" | "tiptapExtensions">> & {
+    key: string;
+}): BlockNoteExtension;

package/types/src/editor/BlockNoteExtensions.d.ts

@@ -3,7 +3,7 @@ import * as Y from "yjs";
 import type { ThreadStore } from "../comments/index.js";
 import { BlockNoteDOMAttributes, BlockSchema, BlockSpecs, InlineContentSchema, InlineContentSpecs, StyleSchema, StyleSpecs } from "../schema/index.js";
 import type { BlockNoteEditor, BlockNoteEditorOptions, SupportedExtension } from "./BlockNoteEditor.js";
-import { BlockNoteSchema } from "./BlockNoteSchema.js";
+import { BlockNoteSchema } from "../blocks/BlockNoteSchema.js";
 type ExtensionOptions<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
     editor: BlockNoteEditor<BSchema, I, S>;
     domAttributes: Partial<BlockNoteDOMAttributes>;

package/types/src/editor/defaultColors.d.ts

@@ -1,76 +1,8 @@
-export declare const COLORS_DEFAULT: {
-    gray: {
-        text: string;
-        background: string;
-    };
-    brown: {
-        text: string;
-        background: string;
-    };
-    red: {
-        text: string;
-        background: string;
-    };
-    orange: {
-        text: string;
-        background: string;
-    };
-    yellow: {
-        text: string;
-        background: string;
-    };
-    green: {
-        text: string;
-        background: string;
-    };
-    blue: {
-        text: string;
-        background: string;
-    };
-    purple: {
-        text: string;
-        background: string;
-    };
-    pink: {
-        text: string;
-        background: string;
-    };
-};
-export declare const COLORS_DARK_MODE_DEFAULT: {
-    gray: {
-        text: string;
-        background: string;
-    };
-    brown: {
-        text: string;
-        background: string;
-    };
-    red: {
-        text: string;
-        background: string;
-    };
-    orange: {
-        text: string;
-        background: string;
-    };
-    yellow: {
-        text: string;
-        background: string;
-    };
-    green: {
-        text: string;
-        background: string;
-    };
-    blue: {
-        text: string;
-        background: string;
-    };
-    purple: {
-        text: string;
-        background: string;
-    };
-    pink: {
-        text: string;
-        background: string;
-    };
-};
+export declare const COLORS_DEFAULT: Record<string, {
+    text: string;
+    background: string;
+}>;
+export declare const COLORS_DARK_MODE_DEFAULT: Record<string, {
+    text: string;
+    background: string;
+}>;

package/types/src/editor/managers/BlockManager.d.ts

@@ -0,0 +1,114 @@
+import { Block, DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, PartialBlock } from "../../blocks/defaultBlocks.js";
+import { BlockIdentifier, BlockSchema, InlineContentSchema, StyleSchema } from "../../schema/index.js";
+import { BlockNoteEditor } from "../BlockNoteEditor.js";
+export declare class BlockManager<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema> {
+    private editor;
+    constructor(editor: BlockNoteEditor<BSchema, ISchema, SSchema>);
+    /**
+     * Gets a snapshot of all top-level (non-nested) blocks in the editor.
+     * @returns A snapshot of all top-level (non-nested) blocks in the editor.
+     */
+    get document(): Block<BSchema, ISchema, SSchema>[];
+    /**
+     * Gets a snapshot of an existing block from the editor.
+     * @param blockIdentifier The identifier of an existing block that should be
+     * retrieved.
+     * @returns The block that matches the identifier, or `undefined` if no
+     * matching block was found.
+     */
+    getBlock(blockIdentifier: BlockIdentifier): Block<BSchema, ISchema, SSchema> | undefined;
+    /**
+     * Gets a snapshot of the previous sibling of an existing block from the
+     * editor.
+     * @param blockIdentifier The identifier of an existing block for which the
+     * previous sibling should be retrieved.
+     * @returns The previous sibling of the block that matches the identifier.
+     * `undefined` if no matching block was found, or it's the first child/block
+     * in the document.
+     */
+    getPrevBlock(blockIdentifier: BlockIdentifier): Block<BSchema, ISchema, SSchema> | undefined;
+    /**
+     * Gets a snapshot of the next sibling of an existing block from the editor.
+     * @param blockIdentifier The identifier of an existing block for which the
+     * next sibling should be retrieved.
+     * @returns The next sibling of the block that matches the identifier.
+     * `undefined` if no matching block was found, or it's the last child/block in
+     * the document.
+     */
+    getNextBlock(blockIdentifier: BlockIdentifier): Block<BSchema, ISchema, SSchema> | undefined;
+    /**
+     * Gets a snapshot of the parent of an existing block from the editor.
+     * @param blockIdentifier The identifier of an existing block for which the
+     * parent should be retrieved.
+     * @returns The parent of the block that matches the identifier. `undefined`
+     * if no matching block was found, or the block isn't nested.
+     */
+    getParentBlock(blockIdentifier: BlockIdentifier): Block<BSchema, ISchema, SSchema> | undefined;
+    /**
+     * Traverses all blocks in the editor depth-first, and executes a callback for each.
+     * @param callback The callback to execute for each block. Returning `false` stops the traversal.
+     * @param reverse Whether the blocks should be traversed in reverse order.
+     */
+    forEachBlock(callback: (block: Block<BSchema, ISchema, SSchema>) => boolean, reverse?: boolean): void;
+    /**
+     * Inserts new blocks into the editor. If a block's `id` is undefined, BlockNote generates one automatically. Throws an
+     * error if the reference block could not be found.
+     * @param blocksToInsert An array of partial blocks that should be inserted.
+     * @param referenceBlock An identifier for an existing block, at which the new blocks should be inserted.
+     * @param placement Whether the blocks should be inserted just before, just after, or nested inside the
+     * `referenceBlock`.
+     */
+    insertBlocks(blocksToInsert: PartialBlock<BSchema, ISchema, SSchema>[], referenceBlock: BlockIdentifier, placement?: "before" | "after"): Block<BSchema, ISchema, SSchema>[];
+    /**
+     * Updates an existing block in the editor. Since updatedBlock is a PartialBlock object, some fields might not be
+     * defined. These undefined fields are kept as-is from the existing block. Throws an error if the block to update could
+     * not be found.
+     * @param blockToUpdate The block that should be updated.
+     * @param update A partial block which defines how the existing block should be changed.
+     */
+    updateBlock(blockToUpdate: BlockIdentifier, update: PartialBlock<BSchema, ISchema, SSchema>): Block<BSchema, ISchema, SSchema>;
+    /**
+     * Removes existing blocks from the editor. Throws an error if any of the blocks could not be found.
+     * @param blocksToRemove An array of identifiers for existing blocks that should be removed.
+     */
+    removeBlocks(blocksToRemove: BlockIdentifier[]): Block<Record<string, import("../../index.js").BlockConfig<string, import("../../index.js").PropSchema, "inline" | "none" | "table">>, InlineContentSchema, StyleSchema>[];
+    /**
+     * Replaces existing blocks in the editor with new blocks. If the blocks that should be removed are not adjacent or
+     * are at different nesting levels, `blocksToInsert` will be inserted at the position of the first block in
+     * `blocksToRemove`. Throws an error if any of the blocks to remove could not be found.
+     * @param blocksToRemove An array of blocks that should be replaced.
+     * @param blocksToInsert An array of partial blocks to replace the old ones with.
+     */
+    replaceBlocks(blocksToRemove: BlockIdentifier[], blocksToInsert: PartialBlock<BSchema, ISchema, SSchema>[]): {
+        insertedBlocks: Block<BSchema, ISchema, SSchema>[];
+        removedBlocks: Block<BSchema, ISchema, SSchema>[];
+    };
+    /**
+     * Checks if the block containing the text cursor can be nested.
+     */
+    canNestBlock(): boolean;
+    /**
+     * Nests the block containing the text cursor into the block above it.
+     */
+    nestBlock(): void;
+    /**
+     * Checks if the block containing the text cursor is nested.
+     */
+    canUnnestBlock(): boolean;
+    /**
+     * Lifts the block containing the text cursor out of its parent.
+     */
+    unnestBlock(): void;
+    /**
+     * Moves the selected blocks up. If the previous block has children, moves
+     * them to the end of its children. If there is no previous block, but the
+     * current blocks share a common parent, moves them out of & before it.
+     */
+    moveBlocksUp(): void;
+    /**
+     * Moves the selected blocks down. If the next block has children, moves
+     * them to the start of its children. If there is no next block, but the
+     * current blocks share a common parent, moves them out of & after it.
+     */
+    moveBlocksDown(): void;
+}