@blocknote/core 0.9.2 → 0.9.4

package/src/extensions/TextColor/TextColorMark.ts

@@ -1,4 +1,5 @@
 import { Mark } from "@tiptap/core";
+import { defaultProps } from "../Blocks/api/defaultProps";
 
 declare module "@tiptap/core" {
   interface Commands<ReturnType> {
@@ -51,7 +52,7 @@ export const TextColorMark = Mark.create({
       setTextColor:
         (color) =>
         ({ commands }) => {
-          if (color !== "default") {
+          if (color !== defaultProps.textColor.default) {
             return commands.setMark(this.name, { color: color });
           }
 

package/src/extensions/TrailingNode/TrailingNodeExtension.ts

@@ -64,7 +64,19 @@ export const TrailingNode = Extension.create<TrailingNodeOptions>({
             if (!lastNode || lastNode.type.name !== "blockContainer") {
               throw new Error("Expected blockContainer");
             }
-            return lastNode.nodeSize > 4; // empty <block><content/></block> is length 4
+
+            const lastContentNode = lastNode.firstChild;
+
+            if (!lastContentNode) {
+              throw new Error("Expected blockContent");
+            }
+
+            // If last node is not empty (size > 4) or it doesn't contain
+            // inline content, we need to add a trailing node.
+            return (
+              lastNode.nodeSize > 4 ||
+              lastContentNode.type.spec.content !== "inline*"
+            );
           },
         },
       }),

package/src/index.ts

@@ -2,12 +2,16 @@ export * from "./BlockNoteEditor";
 export * from "./BlockNoteExtensions";
 export * from "./extensions/Blocks/api/block";
 export * from "./extensions/Blocks/api/blockTypes";
+export * from "./extensions/Blocks/api/defaultProps";
 export * from "./extensions/Blocks/api/defaultBlocks";
 export * from "./extensions/Blocks/api/inlineContentTypes";
+export * from "./extensions/Blocks/api/selectionTypes";
 export * from "./extensions/Blocks/api/serialization";
 export * as blockStyles from "./extensions/Blocks/nodes/Block.module.css";
+export * from "./extensions/Blocks/nodes/BlockContent/ImageBlockContent/uploadToTmpFilesDotOrg_DEV_ONLY";
 export * from "./extensions/FormattingToolbar/FormattingToolbarPlugin";
 export * from "./extensions/HyperlinkToolbar/HyperlinkToolbarPlugin";
+export * from "./extensions/ImageToolbar/ImageToolbarPlugin";
 export * from "./extensions/SideMenu/SideMenuPlugin";
 export * from "./extensions/SlashMenu/BaseSlashMenuItem";
 export * from "./extensions/SlashMenu/SlashMenuPlugin";

package/types/src/BlockNoteEditor.d.ts

@@ -8,6 +8,7 @@ import { Styles } from "./extensions/Blocks/api/inlineContentTypes";
 import { Selection } from "./extensions/Blocks/api/selectionTypes";
 import { FormattingToolbarProsemirrorPlugin } from "./extensions/FormattingToolbar/FormattingToolbarPlugin";
 import { HyperlinkToolbarProsemirrorPlugin } from "./extensions/HyperlinkToolbar/HyperlinkToolbarPlugin";
+import { ImageToolbarProsemirrorPlugin } from "./extensions/ImageToolbar/ImageToolbarPlugin";
 import { SideMenuProsemirrorPlugin } from "./extensions/SideMenu/SideMenuPlugin";
 import { BaseSlashMenuItem } from "./extensions/SlashMenu/BaseSlashMenuItem";
 import { SlashMenuProsemirrorPlugin } from "./extensions/SlashMenu/SlashMenuPlugin";
@@ -62,6 +63,12 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema> = {
      * A list of block types that should be available in the editor.
      */
     blockSchema: BSchema;
+    /**
+     * A custom function to handle file uploads.
+     * @param file The file that should be uploaded.
+     * @returns The URL of the uploaded file.
+     */
+    uploadFile: (file: File) => Promise<string>;
     /**
      * When enabled, allows for collaboration between multiple users.
      */
@@ -100,6 +107,8 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
     readonly formattingToolbar: FormattingToolbarProsemirrorPlugin<BSchema>;
     readonly slashMenu: SlashMenuProsemirrorPlugin<BSchema, any>;
     readonly hyperlinkToolbar: HyperlinkToolbarProsemirrorPlugin<BSchema>;
+    readonly imageToolbar: ImageToolbarProsemirrorPlugin<BSchema>;
+    readonly uploadFile: ((file: File) => Promise<string>) | undefined;
     constructor(options?: Partial<BlockNoteEditorOptions<BSchema>>);
     get prosemirrorView(): import("prosemirror-view").EditorView;
     get domElement(): HTMLDivElement;

package/types/src/BlockNoteExtensions.d.ts

@@ -5,7 +5,7 @@ import { BlockNoteDOMAttributes } from "./extensions/Blocks/api/blockTypes";
 /**
  * Get all the Tiptap extensions BlockNote is configured with by default
  */
-export declare const getBlockNoteExtensions: <BSchema extends Record<string, import("./extensions/Blocks/api/blockTypes").BlockSpec<string, import("./extensions/Blocks/api/blockTypes").PropSchema>>>(opts: {
+export declare const getBlockNoteExtensions: <BSchema extends Record<string, import("./extensions/Blocks/api/blockTypes").BlockSpec<string, import("./extensions/Blocks/api/blockTypes").PropSchema, boolean>>>(opts: {
     editor: BlockNoteEditor<BSchema>;
     domAttributes: Partial<BlockNoteDOMAttributes>;
     blockSchema: BSchema;

package/types/src/extensions/Blocks/NonEditableBlockPlugin.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from "prosemirror-state";
+export declare const NonEditableBlockPlugin: () => Plugin<any>;

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

@@ -1,11 +1,10 @@
-import { Attribute } from "@tiptap/core";
+import { Attributes } from "@tiptap/core";
 import { BlockNoteDOMAttributes } from "../../..";
 import { BlockConfig, BlockSchema, BlockSpec, PropSchema, TipTapNode, TipTapNodeConfig } from "./blockTypes";
+import { ParseRule } from "prosemirror-model";
 export declare function camelToDataKebab(str: string): string;
-export declare function propsToAttributes<BType extends string, PSchema extends PropSchema, ContainsInlineContent extends boolean, BSchema extends BlockSchema>(blockConfig: Omit<BlockConfig<BType, PSchema, ContainsInlineContent, BSchema>, "render">): Record<string, Attribute>;
-export declare function parse<BType extends string, PSchema extends PropSchema, ContainsInlineContent extends boolean, BSchema extends BlockSchema>(blockConfig: Omit<BlockConfig<BType, PSchema, ContainsInlineContent, BSchema>, "render">): {
-    tag: string;
-}[];
+export declare function propsToAttributes<BType extends string, PSchema extends PropSchema, ContainsInlineContent extends boolean, BSchema extends BlockSchema>(blockConfig: Omit<BlockConfig<BType, PSchema, ContainsInlineContent, BSchema>, "render">): Attributes;
+export declare function parse<BType extends string, PSchema extends PropSchema, ContainsInlineContent extends boolean, BSchema extends BlockSchema>(blockConfig: Omit<BlockConfig<BType, PSchema, ContainsInlineContent, BSchema>, "render">): ParseRule[];
 export declare function render<BType extends string, PSchema extends PropSchema, ContainsInlineContent extends boolean, BSchema extends BlockSchema>(blockConfig: Omit<BlockConfig<BType, PSchema, ContainsInlineContent, BSchema>, "render">, HTMLAttributes: Record<string, any>): {
     dom: HTMLDivElement;
     contentDOM: HTMLDivElement;
@@ -13,9 +12,9 @@ export declare function render<BType extends string, PSchema extends PropSchema,
     dom: HTMLDivElement;
     contentDOM?: undefined;
 };
-export declare function createBlockSpec<BType extends string, PSchema extends PropSchema, ContainsInlineContent extends boolean, BSchema extends BlockSchema>(blockConfig: BlockConfig<BType, PSchema, ContainsInlineContent, BSchema>): BlockSpec<BType, PSchema>;
-export declare function createTipTapBlock<Type extends string, Options extends {
+export declare function createBlockSpec<BType extends string, PSchema extends PropSchema, ContainsInlineContent extends false, BSchema extends BlockSchema>(blockConfig: BlockConfig<BType, PSchema, ContainsInlineContent, BSchema>): BlockSpec<BType, PSchema, ContainsInlineContent>;
+export declare function createTipTapBlock<Type extends string, ContainsInlineContent extends boolean, Options extends {
     domAttributes?: BlockNoteDOMAttributes;
 } = {
     domAttributes?: BlockNoteDOMAttributes;
-}, Storage = any>(config: TipTapNodeConfig<Type, Options, Storage>): TipTapNode<Type, Options, Storage>;
+}, Storage = any>(config: TipTapNodeConfig<Type, ContainsInlineContent, Options, Storage>): TipTapNode<Type, ContainsInlineContent, Options, Storage>;

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

@@ -7,28 +7,35 @@ export type BlockNoteDOMElement = "editor" | "blockContainer" | "blockGroup" | "
 export type BlockNoteDOMAttributes = Partial<{
     [DOMElement in BlockNoteDOMElement]: Record<string, string>;
 }>;
-export type TipTapNodeConfig<Name extends string, Options extends {
+export type TipTapNodeConfig<Name extends string, ContainsInlineContent extends boolean, Options extends {
     domAttributes?: BlockNoteDOMAttributes;
 } = {
     domAttributes?: BlockNoteDOMAttributes;
 }, Storage = any> = {
-    [K in keyof NodeConfig<Options, Storage>]: K extends "name" ? Name : K extends "group" ? never : NodeConfig<Options, Storage>[K];
+    [K in keyof NodeConfig<Options, Storage>]: K extends "name" ? Name : K extends "content" ? ContainsInlineContent extends true ? "inline*" : "" : K extends "group" ? never : NodeConfig<Options, Storage>[K];
+} & {
+    name: Name;
+    content: ContainsInlineContent extends true ? "inline*" : "";
 };
-export type TipTapNode<Name extends string, Options extends {
+export type TipTapNode<Name extends string, ContainsInlineContent extends boolean, Options extends {
     domAttributes?: BlockNoteDOMAttributes;
 } = {
     domAttributes?: BlockNoteDOMAttributes;
-}, Storage = any> = Node<Options, Storage> & {
-    name: Name;
-    group: "blockContent";
+}, Storage = any> = {
+    [Key in keyof Node<Options, Storage>]: Key extends "name" ? Name : Key extends "config" ? {
+        [ConfigKey in keyof Node<Options, Storage>["config"]]: ConfigKey extends "group" ? "blockContent" : ConfigKey extends "content" ? ContainsInlineContent extends true ? "inline*" : "" : NodeConfig<Options, Storage>["config"][ConfigKey];
+    } & {
+        group: "blockContent";
+        content: ContainsInlineContent extends true ? "inline*" : "";
+    } : Node<Options, Storage>["config"][Key];
 };
-export type PropSpec = {
-    values?: readonly string[];
-    default: string;
+export type PropSpec<PType extends boolean | number | string> = {
+    values?: readonly PType[];
+    default: PType;
 };
-export type PropSchema = Record<string, PropSpec>;
+export type PropSchema = Record<string, PropSpec<boolean | number | string>>;
 export type Props<PSchema extends PropSchema> = {
-    [PType in keyof PSchema]: PSchema[PType]["values"] extends readonly string[] ? PSchema[PType]["values"][number] : string;
+    [PName in keyof PSchema]: PSchema[PName]["default"] extends boolean ? PSchema[PName]["values"] extends readonly boolean[] ? PSchema[PName]["values"][number] : boolean : PSchema[PName]["default"] extends number ? PSchema[PName]["values"] extends readonly number[] ? PSchema[PName]["values"][number] : number : PSchema[PName]["default"] extends string ? PSchema[PName]["values"] extends readonly string[] ? PSchema[PName]["values"][number] : string : never;
 };
 export type BlockConfig<Type extends string, PSchema extends PropSchema, ContainsInlineContent extends boolean, BSchema extends BlockSchema> = {
     type: Type;
@@ -39,7 +46,7 @@ export type BlockConfig<Type extends string, PSchema extends PropSchema, Contain
      * The custom block to render
      */
     block: SpecificBlock<BSchema & {
-        [k in Type]: BlockSpec<Type, PSchema>;
+        [k in Type]: BlockSpec<Type, PSchema, ContainsInlineContent>;
     }, Type>, 
     /**
      * The BlockNote editor instance
@@ -47,28 +54,30 @@ export type BlockConfig<Type extends string, PSchema extends PropSchema, Contain
      * cast it manually, e.g.: `const e = editor as BlockNoteEditor<typeof mySchema>;`
      */
     editor: BlockNoteEditor<BSchema & {
-        [k in Type]: BlockSpec<Type, PSchema>;
+        [k in Type]: BlockSpec<Type, PSchema, ContainsInlineContent>;
     }>) => ContainsInlineContent extends true ? {
         dom: HTMLElement;
         contentDOM: HTMLElement;
+        destroy?: () => void;
     } : {
         dom: HTMLElement;
+        destroy?: () => void;
     };
 };
-export type BlockSpec<Type extends string, PSchema extends PropSchema> = {
+export type BlockSpec<Type extends string, PSchema extends PropSchema, ContainsInlineContent extends boolean> = {
+    node: TipTapNode<Type, ContainsInlineContent, any>;
     readonly propSchema: PSchema;
-    node: TipTapNode<Type, any>;
 };
-export type TypesMatch<Blocks extends Record<string, BlockSpec<string, PropSchema>>> = Blocks extends {
-    [Type in keyof Blocks]: Type extends string ? Blocks[Type] extends BlockSpec<Type, PropSchema> ? Blocks[Type] : never : never;
+type NamesMatch<Blocks extends Record<string, BlockSpec<string, PropSchema, boolean>>> = Blocks extends {
+    [Type in keyof Blocks]: Type extends string ? Blocks[Type] extends BlockSpec<Type, PropSchema, boolean> ? Blocks[Type] : never : never;
 } ? Blocks : never;
-export type BlockSchema = TypesMatch<Record<string, BlockSpec<string, PropSchema>>>;
+export type BlockSchema = NamesMatch<Record<string, BlockSpec<string, PropSchema, boolean>>>;
 type BlocksWithoutChildren<BSchema extends BlockSchema> = {
     [BType in keyof BSchema]: {
         id: string;
         type: BType;
         props: Props<BSchema[BType]["propSchema"]>;
-        content: InlineContent[];
+        content: BSchema[BType]["node"]["config"]["content"] extends "inline*" ? InlineContent[] : undefined;
     };
 };
 export type Block<BSchema extends BlockSchema = DefaultBlockSchema> = BlocksWithoutChildren<BSchema>[keyof BlocksWithoutChildren<BSchema>] & {
@@ -82,7 +91,7 @@ type PartialBlocksWithoutChildren<BSchema extends BlockSchema> = {
         id: string;
         type: BType;
         props: Partial<Props<BSchema[BType]["propSchema"]>>;
-        content: PartialInlineContent[] | string;
+        content: BSchema[BType]["node"]["config"]["content"] extends "inline*" ? PartialInlineContent[] | string : undefined;
     }>;
 };
 export type PartialBlock<BSchema extends BlockSchema = DefaultBlockSchema> = PartialBlocksWithoutChildren<BSchema>[keyof PartialBlocksWithoutChildren<BSchema>] & Partial<{

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

@@ -1,32 +1,29 @@
-import { TypesMatch } from "./blockTypes";
-export declare const defaultProps: {
-    backgroundColor: {
-        default: "transparent";
-    };
-    textColor: {
-        default: "black";
-    };
-    textAlignment: {
-        default: "left";
-        values: readonly ["left", "center", "right", "justify"];
-    };
-};
-export type DefaultProps = typeof defaultProps;
 export declare const defaultBlockSchema: {
     readonly paragraph: {
-        readonly propSchema: {
+        node: import("./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: "transparent";
+                default: "default";
             };
             textColor: {
-                default: "black";
+                default: "default";
             };
             textAlignment: {
                 default: "left";
                 values: readonly ["left", "center", "right", "justify"];
             };
         };
-        readonly node: import("./blockTypes").TipTapNode<"paragraph", {
+    };
+    readonly heading: {
+        node: import("./blockTypes").TipTapNode<"heading", true, {
             domAttributes?: Partial<{
                 blockContainer: Record<string, string>;
                 blockGroup: Record<string, string>;
@@ -35,25 +32,25 @@ export declare const defaultBlockSchema: {
                 inlineContent: Record<string, string>;
             }> | undefined;
         }, any>;
-    };
-    readonly heading: {
-        readonly propSchema: {
-            readonly level: {
-                readonly default: "1";
-                readonly values: readonly ["1", "2", "3"];
+        propSchema: {
+            level: {
+                default: number;
+                values: readonly [1, 2, 3];
             };
-            readonly backgroundColor: {
-                default: "transparent";
+            backgroundColor: {
+                default: "default";
             };
-            readonly textColor: {
-                default: "black";
+            textColor: {
+                default: "default";
             };
-            readonly textAlignment: {
+            textAlignment: {
                 default: "left";
                 values: readonly ["left", "center", "right", "justify"];
             };
         };
-        readonly node: import("./blockTypes").TipTapNode<"heading", {
+    };
+    readonly bulletListItem: {
+        node: import("./blockTypes").TipTapNode<"bulletListItem", true, {
             domAttributes?: Partial<{
                 blockContainer: Record<string, string>;
                 blockGroup: Record<string, string>;
@@ -62,21 +59,21 @@ export declare const defaultBlockSchema: {
                 inlineContent: Record<string, string>;
             }> | undefined;
         }, any>;
-    };
-    readonly bulletListItem: {
-        readonly propSchema: {
+        propSchema: {
             backgroundColor: {
-                default: "transparent";
+                default: "default";
             };
             textColor: {
-                default: "black";
+                default: "default";
             };
             textAlignment: {
                 default: "left";
                 values: readonly ["left", "center", "right", "justify"];
             };
         };
-        readonly node: import("./blockTypes").TipTapNode<"bulletListItem", {
+    };
+    readonly numberedListItem: {
+        node: import("./blockTypes").TipTapNode<"numberedListItem", true, {
             domAttributes?: Partial<{
                 blockContainer: Record<string, string>;
                 blockGroup: Record<string, string>;
@@ -85,29 +82,36 @@ export declare const defaultBlockSchema: {
                 inlineContent: Record<string, string>;
             }> | undefined;
         }, any>;
-    };
-    readonly numberedListItem: {
-        readonly propSchema: {
+        propSchema: {
             backgroundColor: {
-                default: "transparent";
+                default: "default";
             };
             textColor: {
-                default: "black";
+                default: "default";
             };
             textAlignment: {
                 default: "left";
                 values: readonly ["left", "center", "right", "justify"];
             };
         };
-        readonly node: import("./blockTypes").TipTapNode<"numberedListItem", {
-            domAttributes?: Partial<{
-                blockContainer: Record<string, string>;
-                blockGroup: Record<string, string>;
-                editor: Record<string, string>;
-                blockContent: Record<string, string>;
-                inlineContent: Record<string, string>;
-            }> | undefined;
-        }, any>;
     };
+    readonly image: import("./blockTypes").BlockSpec<"image", {
+        textAlignment: {
+            default: "left";
+            values: readonly ["left", "center", "right", "justify"];
+        };
+        backgroundColor: {
+            default: "default";
+        };
+        url: {
+            default: "";
+        };
+        caption: {
+            default: "";
+        };
+        width: {
+            default: 512;
+        };
+    }, false>;
 };
-export type DefaultBlockSchema = TypesMatch<typeof defaultBlockSchema>;
+export type DefaultBlockSchema = typeof defaultBlockSchema;

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

@@ -0,0 +1,14 @@
+import { Props } from "./blockTypes";
+export declare const defaultProps: {
+    backgroundColor: {
+        default: "default";
+    };
+    textColor: {
+        default: "default";
+    };
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+};
+export type DefaultProps = Props<typeof defaultProps>;

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

@@ -1,9 +1,43 @@
-export declare const HeadingBlockContent: import("../../../api/blockTypes").TipTapNode<"heading", {
-    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 headingPropSchema: {
+    level: {
+        default: number;
+        values: readonly [1, 2, 3];
+    };
+    backgroundColor: {
+        default: "default";
+    };
+    textColor: {
+        default: "default";
+    };
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+};
+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"];
+        };
+    };
+};

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

@@ -0,0 +1,6 @@
+import "@uppy/core/dist/style.css";
+import "@uppy/dashboard/dist/style.css";
+import "@uppy/drag-drop/dist/style.css";
+import "@uppy/file-input/dist/style.css";
+import "@uppy/progress-bar/dist/style.css";
+export declare const Image: BlockSpec<BType, PSchema, ContainsInlineContent>;

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

@@ -0,0 +1,37 @@
+import { BlockSpec } from "../../../api/blockTypes";
+export declare const imagePropSchema: {
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+    backgroundColor: {
+        default: "default";
+    };
+    url: {
+        default: "";
+    };
+    caption: {
+        default: "";
+    };
+    width: {
+        default: 512;
+    };
+};
+export declare const Image: BlockSpec<"image", {
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+    backgroundColor: {
+        default: "default";
+    };
+    url: {
+        default: "";
+    };
+    caption: {
+        default: "";
+    };
+    width: {
+        default: 512;
+    };
+}, false>;

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

@@ -0,0 +1 @@
+export declare const uploadToTmpFilesDotOrg_DEV_ONLY: (file: File) => Promise<any>;

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

@@ -0,0 +1 @@
+export declare const uploadToTmpFilesOrg: (file: File) => Promise<any>;

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

@@ -1,9 +1,35 @@
-export declare const BulletListItemBlockContent: import("../../../../api/blockTypes").TipTapNode<"bulletListItem", {
-    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 bulletListItemPropSchema: {
+    backgroundColor: {
+        default: "default";
+    };
+    textColor: {
+        default: "default";
+    };
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+};
+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"];
+        };
+    };
+};

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

@@ -1,9 +1,35 @@
-export declare const NumberedListItemBlockContent: import("../../../../api/blockTypes").TipTapNode<"numberedListItem", {
-    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 numberedListItemPropSchema: {
+    backgroundColor: {
+        default: "default";
+    };
+    textColor: {
+        default: "default";
+    };
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+};
+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"];
+        };
+    };
+};