@blocknote/core 0.9.6 → 0.10.0

package/types/src/extensions/Blocks/api/defaultProps.d.ts

@@ -1,4 +1,4 @@
-import { Props } from "./blockTypes";
+import { Props } from "./blocks/types";
 export declare const defaultProps: {
     backgroundColor: {
         default: "default";
@@ -12,3 +12,4 @@ export declare const defaultProps: {
     };
 };
 export type DefaultProps = Props<typeof defaultProps>;
+export declare const inheritedProps: string[];

package/types/src/extensions/Blocks/api/inlineContent/createSpec.d.ts

@@ -0,0 +1,21 @@
+import { ParseRule } from "@tiptap/pm/model";
+import { StyleSchema } from "../styles/types";
+import { CustomInlineContentConfig, InlineContentConfig, InlineContentFromConfig, InlineContentSpec } from "./types";
+export type CustomInlineContentImplementation<T extends InlineContentConfig, S extends StyleSchema> = {
+    render: (
+    /**
+     * The custom inline content to render
+     */
+    inlineContent: InlineContentFromConfig<T, S>
+    /**
+     * The BlockNote editor instance
+     * This is typed generically. If you want an editor with your custom schema, you need to
+     * cast it manually, e.g.: `const e = editor as BlockNoteEditor<typeof mySchema>;`
+     */
+    ) => {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+    };
+};
+export declare function getInlineContentParseRules(config: CustomInlineContentConfig): ParseRule[];
+export declare function createInlineContentSpec<T extends CustomInlineContentConfig, S extends StyleSchema>(inlineContentConfig: T, inlineContentImplementation: CustomInlineContentImplementation<T, S>): InlineContentSpec<T>;

package/types/src/extensions/Blocks/api/inlineContent/internal.d.ts

@@ -0,0 +1,25 @@
+import { Node } from "@tiptap/core";
+import { Props, PropSchema } from "../blocks/types";
+import { InlineContentConfig, InlineContentImplementation, InlineContentSchemaFromSpecs, InlineContentSpecs } from "./types";
+export declare function addInlineContentAttributes<IType extends string, PSchema extends PropSchema>(element: {
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+}, inlineContentType: IType, inlineContentProps: Props<PSchema>, propSchema: PSchema): {
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+};
+export declare function createInternalInlineContentSpec<T extends InlineContentConfig>(config: T, implementation: InlineContentImplementation<T>): {
+    config: T;
+    implementation: InlineContentImplementation<T>;
+};
+export declare function createInlineContentSpecFromTipTapNode<T extends Node, P extends PropSchema>(node: T, propSchema: P): {
+    config: {
+        type: T["name"];
+        propSchema: P;
+        content: "styled" | "none";
+    };
+    implementation: {
+        node: Node<any, any>;
+    };
+};
+export declare function getInlineContentSchemaFromSpecs<T extends InlineContentSpecs>(specs: T): InlineContentSchemaFromSpecs<T>;

package/types/src/extensions/Blocks/api/inlineContent/types.d.ts

@@ -0,0 +1,62 @@
+import { Node } from "@tiptap/core";
+import { PropSchema, Props } from "../blocks/types";
+import { StyleSchema, Styles } from "../styles/types";
+export type CustomInlineContentConfig = {
+    type: string;
+    content: "styled" | "none";
+    readonly propSchema: PropSchema;
+};
+export type InlineContentConfig = CustomInlineContentConfig | "text" | "link";
+export type InlineContentImplementation<T extends InlineContentConfig> = T extends "link" | "text" ? undefined : {
+    node: Node;
+};
+export type InlineContentSpec<T extends InlineContentConfig> = {
+    config: T;
+    implementation: InlineContentImplementation<T>;
+};
+export type InlineContentSchema = Record<string, InlineContentConfig>;
+export type InlineContentSpecs = {
+    text: {
+        config: "text";
+        implementation: undefined;
+    };
+    link: {
+        config: "link";
+        implementation: undefined;
+    };
+} & Record<string, InlineContentSpec<InlineContentConfig>>;
+export type InlineContentSchemaFromSpecs<T extends InlineContentSpecs> = {
+    [K in keyof T]: T[K]["config"];
+};
+export type CustomInlineContentFromConfig<I extends CustomInlineContentConfig, S extends StyleSchema> = {
+    type: I["type"];
+    props: Props<I["propSchema"]>;
+    content: I["content"] extends "styled" ? StyledText<S>[] : I["content"] extends "plain" ? string : I["content"] extends "none" ? undefined : never;
+};
+export type InlineContentFromConfig<I extends InlineContentConfig, S extends StyleSchema> = I extends "text" ? StyledText<S> : I extends "link" ? Link<S> : I extends CustomInlineContentConfig ? CustomInlineContentFromConfig<I, S> : never;
+export type PartialCustomInlineContentFromConfig<I extends CustomInlineContentConfig, S extends StyleSchema> = {
+    type: I["type"];
+    props?: Props<I["propSchema"]>;
+    content: I["content"] extends "styled" ? StyledText<S>[] | string : I["content"] extends "plain" ? string : I["content"] extends "none" ? undefined : never;
+};
+export type PartialInlineContentFromConfig<I extends InlineContentConfig, S extends StyleSchema> = I extends "text" ? string | StyledText<S> : I extends "link" ? PartialLink<S> : I extends CustomInlineContentConfig ? PartialCustomInlineContentFromConfig<I, S> : never;
+export type StyledText<T extends StyleSchema> = {
+    type: "text";
+    text: string;
+    styles: Styles<T>;
+};
+export type Link<T extends StyleSchema> = {
+    type: "link";
+    href: string;
+    content: StyledText<T>[];
+};
+export type PartialLink<T extends StyleSchema> = Omit<Link<T>, "content"> & {
+    content: string | Link<T>["content"];
+};
+export type InlineContent<I extends InlineContentSchema, T extends StyleSchema> = InlineContentFromConfig<I[keyof I], T>;
+type PartialInlineContentElement<I extends InlineContentSchema, T extends StyleSchema> = PartialInlineContentFromConfig<I[keyof I], T>;
+export type PartialInlineContent<I extends InlineContentSchema, T extends StyleSchema> = PartialInlineContentElement<I, T>[] | string;
+export declare function isLinkInlineContent<T extends StyleSchema>(content: InlineContent<any, T>): content is Link<T>;
+export declare function isPartialLinkInlineContent<T extends StyleSchema>(content: PartialInlineContentElement<any, T>): content is PartialLink<T>;
+export declare function isStyledTextInlineContent<T extends StyleSchema>(content: PartialInlineContentElement<any, T>): content is StyledText<T>;
+export {};

package/types/src/extensions/Blocks/api/selectionTypes.d.ts

@@ -1,4 +1,6 @@
-import { Block, BlockSchema } from "./blockTypes";
-export type Selection<BSchema extends BlockSchema> = {
-    blocks: Block<BSchema>[];
+import { Block, BlockSchema } from "./blocks/types";
+import { InlineContentSchema } from "./inlineContent/types";
+import { StyleSchema } from "./styles/types";
+export type Selection<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
+    blocks: Block<BSchema, I, S>[];
 };

package/types/src/extensions/Blocks/api/styles/createSpec.d.ts

@@ -0,0 +1,13 @@
+import { ParseRule } from "@tiptap/pm/model";
+import { StyleConfig, StyleSpec } from "./types";
+export type CustomStyleImplementation<T extends StyleConfig> = {
+    render: T["propSchema"] extends "boolean" ? () => {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+    } : (value: string) => {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+    };
+};
+export declare function getStyleParseRules(config: StyleConfig): ParseRule[];
+export declare function createStyleSpec<T extends StyleConfig>(styleConfig: T, styleImplementation: CustomStyleImplementation<T>): StyleSpec<T>;

package/types/src/extensions/Blocks/api/styles/internal.d.ts

@@ -0,0 +1,22 @@
+import { Attributes, Mark } from "@tiptap/core";
+import { StyleConfig, StyleImplementation, StylePropSchema, StyleSchemaFromSpecs, StyleSpecs } from "./types";
+export declare function stylePropsToAttributes(propSchema: StylePropSchema): Attributes;
+export declare function addStyleAttributes<SType extends string, PSchema extends StylePropSchema>(element: {
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+}, styleType: SType, styleValue: PSchema extends "boolean" ? undefined : string, propSchema: PSchema): {
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+};
+export declare function createInternalStyleSpec<T extends StyleConfig>(config: T, implementation: StyleImplementation): {
+    config: T;
+    implementation: StyleImplementation;
+};
+export declare function createStyleSpecFromTipTapMark<T extends Mark, P extends StylePropSchema>(mark: T, propSchema: P): {
+    config: {
+        type: T["name"];
+        propSchema: P;
+    };
+    implementation: StyleImplementation;
+};
+export declare function getStyleSchemaFromSpecs<T extends StyleSpecs>(specs: T): StyleSchemaFromSpecs<T>;

package/types/src/extensions/Blocks/api/styles/types.d.ts

@@ -0,0 +1,21 @@
+import { Mark } from "@tiptap/core";
+export type StylePropSchema = "boolean" | "string";
+export type StyleConfig = {
+    type: string;
+    readonly propSchema: StylePropSchema;
+};
+export type StyleImplementation = {
+    mark: Mark;
+};
+export type StyleSpec<T extends StyleConfig> = {
+    config: T;
+    implementation: StyleImplementation;
+};
+export type StyleSchema = Record<string, StyleConfig>;
+export type StyleSpecs = Record<string, StyleSpec<StyleConfig>>;
+export type StyleSchemaFromSpecs<T extends StyleSpecs> = {
+    [K in keyof T]: T[K]["config"];
+};
+export type Styles<T extends StyleSchema> = {
+    [K in keyof T]?: T[K]["propSchema"] extends "boolean" ? boolean : T[K]["propSchema"] extends "string" ? string : never;
+};

package/types/src/extensions/Blocks/nodes/BlockContainer.d.ts

@@ -1,5 +1,8 @@
 import { Node } from "@tiptap/core";
-import { BlockSchema, PartialBlock } from "../api/blockTypes";
+import { BlockNoteEditor } from "../../../BlockNoteEditor";
+import { BlockSchema, PartialBlock } from "../api/blocks/types";
+import { InlineContentSchema } from "../api/inlineContent/types";
+import { StyleSchema } from "../api/styles/types";
 declare module "@tiptap/core" {
     interface Commands<ReturnType> {
         block: {
@@ -7,8 +10,8 @@ declare module "@tiptap/core" {
             BNDeleteBlock: (posInBlock: number) => ReturnType;
             BNMergeBlocks: (posBetweenBlocks: number) => ReturnType;
             BNSplitBlock: (posInBlock: number, keepType: boolean) => ReturnType;
-            BNUpdateBlock: <BSchema extends BlockSchema>(posInBlock: number, block: PartialBlock<BSchema>) => ReturnType;
-            BNCreateOrUpdateBlock: <BSchema extends BlockSchema>(posInBlock: number, block: PartialBlock<BSchema>) => ReturnType;
+            BNUpdateBlock: <BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(posInBlock: number, block: PartialBlock<BSchema, I, S>) => ReturnType;
+            BNCreateOrUpdateBlock: <BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(posInBlock: number, block: PartialBlock<BSchema, I, S>) => ReturnType;
         };
     }
 }
@@ -17,10 +20,11 @@ declare module "@tiptap/core" {
  */
 export declare const BlockContainer: Node<{
     domAttributes?: Partial<{
+        editor: Record<string, string>;
         blockContainer: Record<string, string>;
         blockGroup: Record<string, string>;
-        editor: Record<string, string>;
         blockContent: Record<string, string>;
         inlineContent: Record<string, string>;
     }> | undefined;
+    editor: BlockNoteEditor<BlockSchema, InlineContentSchema, StyleSchema>;
 }, any>;

package/types/src/extensions/Blocks/nodes/BlockContent/HeadingBlockContent/HeadingBlockContent.d.ts

@@ -15,29 +15,44 @@ export declare const headingPropSchema: {
     };
 };
 export declare const Heading: {
-    node: import("../../../api/blockTypes").TipTapNode<"heading", true, {
-        domAttributes?: Partial<{
-            blockContainer: Record<string, string>;
-            blockGroup: Record<string, string>;
-            editor: Record<string, string>;
-            blockContent: Record<string, string>;
-            inlineContent: Record<string, string>;
-        }> | undefined;
-    }, any>;
-    propSchema: {
-        level: {
-            default: number;
-            values: readonly [1, 2, 3];
-        };
-        backgroundColor: {
-            default: "default";
-        };
-        textColor: {
-            default: "default";
-        };
-        textAlignment: {
-            default: "left";
-            values: readonly ["left", "center", "right", "justify"];
+    config: {
+        type: "heading";
+        content: "inline";
+        propSchema: {
+            level: {
+                default: number;
+                values: readonly [1, 2, 3];
+            };
+            backgroundColor: {
+                default: "default";
+            };
+            textColor: {
+                default: "default";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
         };
     };
+    implementation: import("../../../api/blocks/types").TiptapBlockImplementation<{
+        type: "heading";
+        content: "inline";
+        propSchema: {
+            level: {
+                default: number;
+                values: readonly [1, 2, 3];
+            };
+            backgroundColor: {
+                default: "default";
+            };
+            textColor: {
+                default: "default";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+        };
+    }, any, import("../../../../..").InlineContentSchema, import("../../../../..").StyleSchema>;
 };

package/types/src/extensions/Blocks/nodes/BlockContent/ImageBlockContent/ImageBlockContent.d.ts

@@ -1,4 +1,7 @@
-import { BlockSpec } from "../../../api/blockTypes";
+import { BlockNoteEditor } from "../../../../../BlockNoteEditor";
+import { BlockFromConfig, BlockSchemaWithBlock } from "../../../api/blocks/types";
+import { InlineContentSchema } from "../../../api/inlineContent/types";
+import { StyleSchema } from "../../../api/styles/types";
 export declare const imagePropSchema: {
     textAlignment: {
         default: "left";
@@ -17,21 +20,76 @@ export declare const imagePropSchema: {
         default: 512;
     };
 };
-export declare const Image: BlockSpec<"image", {
-    textAlignment: {
-        default: "left";
-        values: readonly ["left", "center", "right", "justify"];
-    };
-    backgroundColor: {
-        default: "default";
-    };
-    url: {
-        default: "";
+declare const blockConfig: {
+    type: "image";
+    propSchema: {
+        textAlignment: {
+            default: "left";
+            values: readonly ["left", "center", "right", "justify"];
+        };
+        backgroundColor: {
+            default: "default";
+        };
+        url: {
+            default: "";
+        };
+        caption: {
+            default: "";
+        };
+        width: {
+            default: 512;
+        };
     };
-    caption: {
-        default: "";
-    };
-    width: {
-        default: 512;
+    content: "none";
+};
+export declare const renderImage: (block: BlockFromConfig<typeof blockConfig, InlineContentSchema, StyleSchema>, editor: BlockNoteEditor<BlockSchemaWithBlock<"image", typeof blockConfig>>) => {
+    dom: HTMLDivElement;
+    destroy: () => void;
+};
+export declare const Image: {
+    config: {
+        type: "image";
+        propSchema: {
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+            backgroundColor: {
+                default: "default";
+            };
+            url: {
+                default: "";
+            };
+            caption: {
+                default: "";
+            };
+            width: {
+                default: 512;
+            };
+        };
+        content: "none";
     };
-}, false>;
+    implementation: import("../../../api/blocks/types").TiptapBlockImplementation<{
+        type: "image";
+        propSchema: {
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+            backgroundColor: {
+                default: "default";
+            };
+            url: {
+                default: "";
+            };
+            caption: {
+                default: "";
+            };
+            width: {
+                default: 512;
+            };
+        };
+        content: "none";
+    }, any, InlineContentSchema, StyleSchema>;
+};
+export {};

package/types/src/extensions/Blocks/nodes/BlockContent/ListItemBlockContent/BulletListItemBlockContent/BulletListItemBlockContent.d.ts

@@ -11,25 +11,36 @@ export declare const bulletListItemPropSchema: {
     };
 };
 export declare const BulletListItem: {
-    node: import("../../../../api/blockTypes").TipTapNode<"bulletListItem", true, {
-        domAttributes?: Partial<{
-            blockContainer: Record<string, string>;
-            blockGroup: Record<string, string>;
-            editor: Record<string, string>;
-            blockContent: Record<string, string>;
-            inlineContent: Record<string, string>;
-        }> | undefined;
-    }, any>;
-    propSchema: {
-        backgroundColor: {
-            default: "default";
-        };
-        textColor: {
-            default: "default";
-        };
-        textAlignment: {
-            default: "left";
-            values: readonly ["left", "center", "right", "justify"];
+    config: {
+        type: "bulletListItem";
+        content: "inline";
+        propSchema: {
+            backgroundColor: {
+                default: "default";
+            };
+            textColor: {
+                default: "default";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
         };
     };
+    implementation: import("../../../../api/blocks/types").TiptapBlockImplementation<{
+        type: "bulletListItem";
+        content: "inline";
+        propSchema: {
+            backgroundColor: {
+                default: "default";
+            };
+            textColor: {
+                default: "default";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+        };
+    }, any, import("../../../../../..").InlineContentSchema, import("../../../../../..").StyleSchema>;
 };

package/types/src/extensions/Blocks/nodes/BlockContent/ListItemBlockContent/NumberedListItemBlockContent/NumberedListItemBlockContent.d.ts

@@ -11,25 +11,36 @@ export declare const numberedListItemPropSchema: {
     };
 };
 export declare const NumberedListItem: {
-    node: import("../../../../api/blockTypes").TipTapNode<"numberedListItem", true, {
-        domAttributes?: Partial<{
-            blockContainer: Record<string, string>;
-            blockGroup: Record<string, string>;
-            editor: Record<string, string>;
-            blockContent: Record<string, string>;
-            inlineContent: Record<string, string>;
-        }> | undefined;
-    }, any>;
-    propSchema: {
-        backgroundColor: {
-            default: "default";
-        };
-        textColor: {
-            default: "default";
-        };
-        textAlignment: {
-            default: "left";
-            values: readonly ["left", "center", "right", "justify"];
+    config: {
+        type: "numberedListItem";
+        content: "inline";
+        propSchema: {
+            backgroundColor: {
+                default: "default";
+            };
+            textColor: {
+                default: "default";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
         };
     };
+    implementation: import("../../../../api/blocks/types").TiptapBlockImplementation<{
+        type: "numberedListItem";
+        content: "inline";
+        propSchema: {
+            backgroundColor: {
+                default: "default";
+            };
+            textColor: {
+                default: "default";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+        };
+    }, any, import("../../../../../..").InlineContentSchema, import("../../../../../..").StyleSchema>;
 };

package/types/src/extensions/Blocks/nodes/BlockContent/ParagraphBlockContent/ParagraphBlockContent.d.ts

@@ -10,35 +10,43 @@ export declare const paragraphPropSchema: {
         values: readonly ["left", "center", "right", "justify"];
     };
 };
-export declare const ParagraphBlockContent: import("../../../api/blockTypes").TipTapNode<"paragraph", true, {
-    domAttributes?: Partial<{
-        blockContainer: Record<string, string>;
-        blockGroup: Record<string, string>;
-        editor: Record<string, string>;
-        blockContent: Record<string, string>;
-        inlineContent: Record<string, string>;
-    }> | undefined;
-}, any>;
+export declare const ParagraphBlockContent: import("@tiptap/core").Node<any, any> & {
+    name: "paragraph";
+    config: {
+        content: "inline*";
+    };
+};
 export declare const Paragraph: {
-    node: import("../../../api/blockTypes").TipTapNode<"paragraph", true, {
-        domAttributes?: Partial<{
-            blockContainer: Record<string, string>;
-            blockGroup: Record<string, string>;
-            editor: Record<string, string>;
-            blockContent: Record<string, string>;
-            inlineContent: Record<string, string>;
-        }> | undefined;
-    }, any>;
-    propSchema: {
-        backgroundColor: {
-            default: "default";
-        };
-        textColor: {
-            default: "default";
-        };
-        textAlignment: {
-            default: "left";
-            values: readonly ["left", "center", "right", "justify"];
+    config: {
+        type: "paragraph";
+        content: "inline";
+        propSchema: {
+            backgroundColor: {
+                default: "default";
+            };
+            textColor: {
+                default: "default";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
         };
     };
+    implementation: import("../../../../..").TiptapBlockImplementation<{
+        type: "paragraph";
+        content: "inline";
+        propSchema: {
+            backgroundColor: {
+                default: "default";
+            };
+            textColor: {
+                default: "default";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+        };
+    }, any, import("../../../../..").InlineContentSchema, import("../../../../..").StyleSchema>;
 };

package/types/src/extensions/Blocks/nodes/BlockContent/TableBlockContent/TableBlockContent.d.ts

@@ -0,0 +1,53 @@
+import { Node } from "@tiptap/core";
+export declare const tablePropSchema: {
+    backgroundColor: {
+        default: "default";
+    };
+    textColor: {
+        default: "default";
+    };
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+};
+export declare const TableBlockContent: Node<any, any> & {
+    name: "table";
+    config: {
+        content: "tableRow+";
+    };
+};
+export declare const Table: {
+    config: {
+        type: "table";
+        content: "table";
+        propSchema: {
+            backgroundColor: {
+                default: "default";
+            };
+            textColor: {
+                default: "default";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+        };
+    };
+    implementation: import("../../../../..").TiptapBlockImplementation<{
+        type: "table";
+        content: "table";
+        propSchema: {
+            backgroundColor: {
+                default: "default";
+            };
+            textColor: {
+                default: "default";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+        };
+    }, any, import("../../../../..").InlineContentSchema, import("../../../../..").StyleSchema>;
+};

package/types/src/extensions/Blocks/nodes/BlockContent/TableBlockContent/TableExtension.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from "@tiptap/core";
+export declare const TableExtension: Extension<any, any>;

package/types/src/extensions/Blocks/nodes/BlockContent/defaultBlockHelpers.d.ts

@@ -0,0 +1,12 @@
+import { BlockNoteEditor } from "../../../../BlockNoteEditor";
+import { Block } from "../../api/blocks/types";
+import { InlineContentSchema } from "../../api/inlineContent/types";
+import { StyleSchema } from "../../api/styles/types";
+export declare function createDefaultBlockDOMOutputSpec(blockName: string, htmlTag: string, blockContentHTMLAttributes: Record<string, string>, inlineContentHTMLAttributes: Record<string, string>): {
+    dom: HTMLDivElement;
+    contentDOM: HTMLElement;
+};
+export declare const defaultBlockToHTML: <BSchema extends Record<string, import("../../api/blocks/types").BlockConfig>, I extends InlineContentSchema, S extends StyleSchema>(block: Block<BSchema, I, S>, editor: BlockNoteEditor<BSchema, I, S>) => {
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+};