@blocknote/core 0.38.0 → 0.39.1

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

@@ -0,0 +1,18 @@
+import { BlockSchema, BlockSchemaFromSpecs, BlockSpecs, CustomBlockNoteSchema, InlineContentSchema, InlineContentSchemaFromSpecs, InlineContentSpecs, StyleSchema, StyleSchemaFromSpecs, StyleSpecs } from "../schema/index.js";
+import { defaultBlockSpecs, defaultInlineContentSpecs, defaultStyleSpecs } from "./defaultBlocks.js";
+export declare class BlockNoteSchema<BSchema extends BlockSchema, ISchema extends InlineContentSchema, SSchema extends StyleSchema> extends CustomBlockNoteSchema<BSchema, ISchema, SSchema> {
+    static create<BSpecs extends BlockSpecs | undefined = undefined, ISpecs extends InlineContentSpecs | undefined = undefined, SSpecs extends StyleSpecs | undefined = undefined>(options?: {
+        /**
+         * A list of custom block types that should be available in the editor.
+         */
+        blockSpecs?: BSpecs;
+        /**
+         * A list of custom InlineContent types that should be available in the editor.
+         */
+        inlineContentSpecs?: ISpecs;
+        /**
+         * A list of custom Styles that should be available in the editor.
+         */
+        styleSpecs?: SSpecs;
+    }): BlockNoteSchema<BSpecs extends undefined ? BlockSchemaFromSpecs<typeof defaultBlockSpecs> : BlockSchemaFromSpecs<NonNullable<BSpecs>>, ISpecs extends undefined ? InlineContentSchemaFromSpecs<typeof defaultInlineContentSpecs> : InlineContentSchemaFromSpecs<NonNullable<ISpecs>>, SSpecs extends undefined ? StyleSchemaFromSpecs<typeof defaultStyleSpecs> : StyleSchemaFromSpecs<NonNullable<SSpecs>>>;
+}

package/types/src/blocks/{CodeBlockContent/CodeBlockContent.d.ts → Code/block.d.ts}

@@ -27,7 +27,7 @@ export type CodeBlockOptions = {
      *   },
      * }
      */
-    supportedLanguages: Record<string, {
+    supportedLanguages?: Record<string, {
         /**
          * The display name of the language.
          */
@@ -42,30 +42,29 @@ export type CodeBlockOptions = {
      */
     createHighlighter?: () => Promise<HighlighterGeneric<any, any>>;
 };
-export declare const shikiParserSymbol: unique symbol;
-export declare const shikiHighlighterPromiseSymbol: unique symbol;
-export declare const defaultCodeBlockPropSchema: {
-    language: {
-        default: string;
+export type CodeBlockConfig = ReturnType<typeof createCodeBlockConfig>;
+export declare const createCodeBlockConfig: (options: CodeBlockOptions) => import("../../index.js").BlockConfig<"codeBlock", {
+    readonly language: {
+        readonly default: string;
     };
-};
-export declare const CodeBlock: {
-    config: {
-        type: "codeBlock";
-        content: "inline";
-        propSchema: {
-            language: {
-                default: string;
-            };
-        };
+}, "inline">;
+export declare const createCodeBlockSpec: (options?: Partial<{
+    indentLineWithTab: boolean;
+    defaultLanguage: string;
+    supportedLanguages: Record<string, {
+        /**
+         * The display name of the language.
+         */
+        name: string;
+        /**
+         * Aliases for this language.
+         */
+        aliases?: string[];
+    }>;
+    createHighlighter: () => Promise<HighlighterGeneric<any, any>>;
+}> | undefined) => import("../../index.js").BlockSpec<"codeBlock", {
+    readonly language: {
+        readonly default: string;
     };
-    implementation: import("../../index.js").TiptapBlockImplementation<{
-        type: "codeBlock";
-        content: "inline";
-        propSchema: {
-            language: {
-                default: string;
-            };
-        };
-    }, any, import("../../index.js").InlineContentSchema, import("../../index.js").StyleSchema>;
-};
+}, "inline">;
+export declare function getLanguageId(options: CodeBlockOptions, languageName: string): string | undefined;

package/types/src/blocks/Code/shiki.d.ts

@@ -0,0 +1,4 @@
+import { CodeBlockOptions } from "./block.js";
+export declare const shikiParserSymbol: unique symbol;
+export declare const shikiHighlighterPromiseSymbol: unique symbol;
+export declare function lazyShikiPlugin(options: CodeBlockOptions): import("prosemirror-state").Plugin<import("prosemirror-highlight").HighlightPluginState>;

package/types/src/blocks/File/block.d.ts

@@ -0,0 +1,37 @@
+export type FileBlockConfig = ReturnType<typeof createFileBlockConfig>;
+export declare const createFileBlockConfig: () => import("../../index.js").BlockConfig<"file", {
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly name: {
+        readonly default: "";
+    };
+    readonly url: {
+        readonly default: "";
+    };
+    readonly caption: {
+        readonly default: "";
+    };
+}, "none">;
+export declare const fileParse: () => (element: HTMLElement) => {
+    backgroundColor: string | undefined;
+    url: string | undefined;
+} | {
+    backgroundColor: string | undefined;
+    caption: string | undefined;
+    url: string | undefined;
+} | undefined;
+export declare const createFileBlockSpec: (options?: Partial<Partial<Record<string, any>>> | undefined) => import("../../index.js").BlockSpec<"file", {
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly name: {
+        readonly default: "";
+    };
+    readonly url: {
+        readonly default: "";
+    };
+    readonly caption: {
+        readonly default: "";
+    };
+}, "none">;

package/types/src/blocks/File/helpers/render/createAddFileButton.d.ts

@@ -0,0 +1,6 @@
+import type { BlockNoteEditor } from "../../../../editor/BlockNoteEditor.js";
+import { BlockConfig, BlockFromConfigNoChildren } from "../../../../schema/index.js";
+export declare const createAddFileButton: (block: BlockFromConfigNoChildren<BlockConfig<string, any, "none">, any, any>, editor: BlockNoteEditor<any, any, any>, buttonIcon?: HTMLElement) => {
+    dom: HTMLDivElement;
+    destroy: () => void;
+};

package/types/src/blocks/File/helpers/render/createFileBlockWrapper.d.ts

@@ -0,0 +1,25 @@
+import type { BlockNoteEditor } from "../../../../editor/BlockNoteEditor.js";
+import { BlockConfig, BlockFromConfigNoChildren } from "../../../../schema/index.js";
+export declare const createFileBlockWrapper: (block: BlockFromConfigNoChildren<BlockConfig<string, {
+    backgroundColor: {
+        default: "default";
+    };
+    name: {
+        default: "";
+    };
+    url: {
+        default: "";
+    };
+    caption: {
+        default: "";
+    };
+    showPreview?: {
+        default: true;
+    };
+}, "none">, any, any>, editor: BlockNoteEditor<any, any, any>, element?: {
+    dom: HTMLElement;
+    destroy?: () => void;
+}, buttonIcon?: HTMLElement) => {
+    dom: HTMLElement;
+    destroy?: () => void;
+};

package/types/src/blocks/{FileBlockContent → File}/helpers/render/createFileNameWithIcon.d.ts

@@ -1,6 +1,10 @@
-import { BlockFromConfig, FileBlockConfig } from "../../../../schema/index.js";
+import { BlockConfig, BlockFromConfigNoChildren } from "../../../../schema/index.js";
 export declare const FILE_ICON_SVG = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"currentColor\"><path d=\"M3 8L9.00319 2H19.9978C20.5513 2 21 2.45531 21 2.9918V21.0082C21 21.556 20.5551 22 20.0066 22H3.9934C3.44476 22 3 21.5501 3 20.9932V8ZM10 4V9H5V20H19V4H10Z\"></path></svg>";
-export declare const createFileNameWithIcon: (block: BlockFromConfig<FileBlockConfig, any, any>) => {
+export declare const createFileNameWithIcon: (block: BlockFromConfigNoChildren<BlockConfig<string, {
+    name: {
+        default: "";
+    };
+}, "none">, any, any>) => {
     dom: HTMLElement;
     destroy?: () => void;
 };

package/types/src/blocks/File/helpers/render/createResizableFileBlockWrapper.d.ts

@@ -0,0 +1,31 @@
+import type { BlockNoteEditor } from "../../../../editor/BlockNoteEditor.js";
+import { BlockConfig, BlockFromConfigNoChildren } from "../../../../schema/index.js";
+export declare const createResizableFileBlockWrapper: (block: BlockFromConfigNoChildren<BlockConfig<string, {
+    backgroundColor: {
+        default: "default";
+    };
+    name: {
+        default: "";
+    };
+    url: {
+        default: "";
+    };
+    caption: {
+        default: "";
+    };
+    showPreview?: {
+        default: true;
+    };
+    previewWidth?: {
+        default: number;
+    };
+    textAlignment?: {
+        default: "left";
+    };
+}, "none">, any, any>, editor: BlockNoteEditor<any, any, any>, element: {
+    dom: HTMLElement;
+    destroy?: () => void;
+}, resizeHandlesContainerElement: HTMLElement, buttonIcon?: HTMLElement) => {
+    dom: HTMLElement;
+    destroy: () => void;
+};

package/types/src/blocks/Heading/block.d.ts

@@ -0,0 +1,71 @@
+declare const HEADING_LEVELS: readonly [1, 2, 3, 4, 5, 6];
+export interface HeadingOptions {
+    defaultLevel?: (typeof HEADING_LEVELS)[number];
+    levels?: readonly number[];
+    allowToggleHeadings?: boolean;
+}
+export type HeadingBlockConfig = ReturnType<typeof createHeadingBlockConfig>;
+export declare const createHeadingBlockConfig: (() => import("../../index.js").BlockConfig<"heading", {
+    readonly isToggleable?: {
+        readonly default: false;
+        readonly optional: true;
+    } | undefined;
+    readonly level: {
+        readonly default: 1 | 2 | 4 | 3 | 5 | 6;
+        readonly values: readonly number[];
+    };
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly textColor: {
+        default: "default";
+    };
+    readonly textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+}, "inline">) | ((options: HeadingOptions) => import("../../index.js").BlockConfig<"heading", {
+    readonly isToggleable?: {
+        readonly default: false;
+        readonly optional: true;
+    } | undefined;
+    readonly level: {
+        readonly default: 1 | 2 | 4 | 3 | 5 | 6;
+        readonly values: readonly number[];
+    };
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly textColor: {
+        default: "default";
+    };
+    readonly textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+}, "inline">);
+export declare const createHeadingBlockSpec: (options?: Partial<{
+    defaultLevel: (typeof HEADING_LEVELS)[number];
+    levels: readonly number[];
+    allowToggleHeadings: boolean;
+}> | undefined) => import("../../index.js").BlockSpec<"heading", {
+    readonly isToggleable?: {
+        readonly default: false;
+        readonly optional: true;
+    } | undefined;
+    readonly level: {
+        readonly default: 1 | 2 | 4 | 3 | 5 | 6;
+        readonly values: readonly number[];
+    };
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly textColor: {
+        default: "default";
+    };
+    readonly textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+}, "inline">;
+export {};

package/types/src/blocks/Image/block.d.ts

@@ -0,0 +1,102 @@
+import { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
+import { BlockFromConfig } from "../../schema/index.js";
+export declare const FILE_IMAGE_ICON_SVG = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"currentColor\"><path d=\"M5 11.1005L7 9.1005L12.5 14.6005L16 11.1005L19 14.1005V5H5V11.1005ZM4 3H20C20.5523 3 21 3.44772 21 4V20C21 20.5523 20.5523 21 20 21H4C3.44772 21 3 20.5523 3 20V4C3 3.44772 3.44772 3 4 3ZM15.5 10C14.6716 10 14 9.32843 14 8.5C14 7.67157 14.6716 7 15.5 7C16.3284 7 17 7.67157 17 8.5C17 9.32843 16.3284 10 15.5 10Z\"></path></svg>";
+export interface ImageOptions {
+    icon?: string;
+}
+export type ImageBlockConfig = ReturnType<typeof createImageBlockConfig>;
+export declare const createImageBlockConfig: (() => import("../../index.js").BlockConfig<"image", {
+    readonly textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly name: {
+        readonly default: "";
+    };
+    readonly url: {
+        readonly default: "";
+    };
+    readonly caption: {
+        readonly default: "";
+    };
+    readonly showPreview: {
+        readonly default: true;
+    };
+    readonly previewWidth: {
+        readonly default: undefined;
+        readonly type: "number";
+    };
+}, "none">) | ((options: ImageOptions) => import("../../index.js").BlockConfig<"image", {
+    readonly textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly name: {
+        readonly default: "";
+    };
+    readonly url: {
+        readonly default: "";
+    };
+    readonly caption: {
+        readonly default: "";
+    };
+    readonly showPreview: {
+        readonly default: true;
+    };
+    readonly previewWidth: {
+        readonly default: undefined;
+        readonly type: "number";
+    };
+}, "none">);
+export declare const imageParse: (_config?: ImageOptions) => (element: HTMLElement) => {
+    backgroundColor: string | undefined;
+    url: string | undefined;
+    previewWidth: number | undefined;
+    name: string | undefined;
+} | {
+    backgroundColor: string | undefined;
+    caption: string | undefined;
+    url: string | undefined;
+    previewWidth: number | undefined;
+    name: string | undefined;
+} | undefined;
+export declare const imageRender: (config?: ImageOptions) => (block: BlockFromConfig<ReturnType<typeof createImageBlockConfig>, any, any>, editor: BlockNoteEditor<Record<"image", ReturnType<typeof createImageBlockConfig>>, any, any>) => {
+    dom: HTMLElement;
+    destroy: () => void;
+};
+export declare const imageToExternalHTML: (_config?: ImageOptions) => (block: BlockFromConfig<ReturnType<typeof createImageBlockConfig>, any, any>, _editor: BlockNoteEditor<Record<"image", ReturnType<typeof createImageBlockConfig>>, any, any>) => {
+    dom: HTMLElement;
+};
+export declare const createImageBlockSpec: (options?: Partial<{
+    icon: string;
+}> | undefined) => import("../../index.js").BlockSpec<"image", {
+    readonly textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly name: {
+        readonly default: "";
+    };
+    readonly url: {
+        readonly default: "";
+    };
+    readonly caption: {
+        readonly default: "";
+    };
+    readonly showPreview: {
+        readonly default: true;
+    };
+    readonly previewWidth: {
+        readonly default: undefined;
+        readonly type: "number";
+    };
+}, "none">;

package/types/src/blocks/ListItem/BulletListItem/block.d.ts

@@ -0,0 +1,25 @@
+export type BulletListItemBlockConfig = ReturnType<typeof createBulletListItemBlockConfig>;
+export declare const createBulletListItemBlockConfig: () => import("../../../index.js").BlockConfig<"bulletListItem", {
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly textColor: {
+        default: "default";
+    };
+    readonly textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+}, "inline">;
+export declare const createBulletListItemBlockSpec: (options?: Partial<Partial<Record<string, any>>> | undefined) => import("../../../index.js").BlockSpec<"bulletListItem", {
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly textColor: {
+        default: "default";
+    };
+    readonly textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+}, "inline">;

package/types/src/blocks/ListItem/CheckListItem/block.d.ts

@@ -0,0 +1,33 @@
+export type CheckListItemBlockConfig = ReturnType<typeof createCheckListItemConfig>;
+export declare const createCheckListItemConfig: () => import("../../../index.js").BlockConfig<"checkListItem", {
+    readonly checked: {
+        readonly default: false;
+        readonly type: "boolean";
+    };
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly textColor: {
+        default: "default";
+    };
+    readonly textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+}, "inline">;
+export declare const createCheckListItemBlockSpec: (options?: Partial<Partial<Record<string, any>>> | undefined) => import("../../../index.js").BlockSpec<"checkListItem", {
+    readonly checked: {
+        readonly default: false;
+        readonly type: "boolean";
+    };
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly textColor: {
+        default: "default";
+    };
+    readonly textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+}, "inline">;

package/types/src/blocks/ListItem/NumberedListItem/IndexingPlugin.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from "@tiptap/pm/state";
+import { DecorationSet } from "@tiptap/pm/view";
+/**
+ * This plugin adds decorations to numbered list items to display their index.
+ */
+export declare const NumberedListIndexingDecorationPlugin: () => Plugin<{
+    decorations: DecorationSet;
+}>;

package/types/src/blocks/ListItem/NumberedListItem/block.d.ts

@@ -0,0 +1,33 @@
+export type NumberedListItemBlockConfig = ReturnType<typeof createNumberedListItemBlockConfig>;
+export declare const createNumberedListItemBlockConfig: () => import("../../../index.js").BlockConfig<"numberedListItem", {
+    readonly start: {
+        readonly default: undefined;
+        readonly type: "number";
+    };
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly textColor: {
+        default: "default";
+    };
+    readonly textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+}, "inline">;
+export declare const createNumberedListItemBlockSpec: (options?: Partial<Partial<Record<string, any>>> | undefined) => import("../../../index.js").BlockSpec<"numberedListItem", {
+    readonly start: {
+        readonly default: undefined;
+        readonly type: "number";
+    };
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly textColor: {
+        default: "default";
+    };
+    readonly textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+}, "inline">;

package/types/src/blocks/ListItem/ToggleListItem/block.d.ts

@@ -0,0 +1,25 @@
+export type ToggleListItemBlockConfig = ReturnType<typeof createToggleListItemBlockConfig>;
+export declare const createToggleListItemBlockConfig: () => import("../../../index.js").BlockConfig<"toggleListItem", {
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly textColor: {
+        default: "default";
+    };
+    readonly textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+}, "inline">;
+export declare const createToggleListItemBlockSpec: (options?: Partial<Partial<Record<string, any>>> | undefined) => import("../../../index.js").BlockSpec<"toggleListItem", {
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly textColor: {
+        default: "default";
+    };
+    readonly textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+}, "inline">;

package/types/src/blocks/PageBreak/block.d.ts

@@ -0,0 +1,11 @@
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema/index.js";
+import { BlockNoteSchema } from "../BlockNoteSchema.js";
+export type PageBreakBlockConfig = ReturnType<typeof createPageBreakBlockConfig>;
+export declare const createPageBreakBlockConfig: () => import("../../index.js").BlockConfig<"pageBreak", {}, "none">;
+export declare const createPageBreakBlockSpec: (options?: Partial<Partial<Record<string, any>>> | undefined) => import("../../index.js").BlockSpec<"pageBreak", {}, "none">;
+/**
+ * Adds page break support to the given schema.
+ */
+export declare const withPageBreak: <B extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(schema: BlockNoteSchema<B, I, S>) => import("../../index.js").CustomBlockNoteSchema<B & {
+    pageBreak: import("../../index.js").BlockConfig<"pageBreak", {}, "none">;
+}, I, S>;

package/types/src/blocks/{PageBreakBlockContent → PageBreak}/getPageBreakSlashMenuItems.d.ts

@@ -1,8 +1,10 @@
 import { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
 import { DefaultSuggestionItem } from "../../extensions/SuggestionMenu/DefaultSuggestionItem.js";
 import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema/index.js";
-import { pageBreakSchema } from "./schema.js";
-export declare function checkPageBreakBlocksInSchema<I extends InlineContentSchema, S extends StyleSchema>(editor: BlockNoteEditor<any, I, S>): editor is BlockNoteEditor<typeof pageBreakSchema.blockSchema, I, S>;
+import { createPageBreakBlockConfig } from "./block.js";
+export declare function checkPageBreakBlocksInSchema<I extends InlineContentSchema, S extends StyleSchema>(editor: BlockNoteEditor<any, I, S>): editor is BlockNoteEditor<{
+    pageBreak: ReturnType<typeof createPageBreakBlockConfig>;
+}, I, S>;
 export declare function getPageBreakSlashMenuItems<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(editor: BlockNoteEditor<BSchema, I, S>): (Omit<DefaultSuggestionItem, "key"> & {
     key: "page_break";
 })[];

package/types/src/blocks/Paragraph/block.d.ts

@@ -0,0 +1,25 @@
+export type ParagraphBlockConfig = ReturnType<typeof createParagraphBlockConfig>;
+export declare const createParagraphBlockConfig: () => import("../../index.js").BlockConfig<"paragraph", {
+    backgroundColor: {
+        default: "default";
+    };
+    textColor: {
+        default: "default";
+    };
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+}, "inline">;
+export declare const createParagraphBlockSpec: (options?: Partial<Partial<Record<string, any>>> | undefined) => import("../../index.js").BlockSpec<"paragraph", {
+    backgroundColor: {
+        default: "default";
+    };
+    textColor: {
+        default: "default";
+    };
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+}, "inline">;

package/types/src/blocks/Quote/block.d.ts

@@ -0,0 +1,17 @@
+export type QuoteBlockConfig = ReturnType<typeof createQuoteBlockConfig>;
+export declare const createQuoteBlockConfig: () => import("../../index.js").BlockConfig<"quote", {
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly textColor: {
+        default: "default";
+    };
+}, "inline">;
+export declare const createQuoteBlockSpec: (options?: Partial<Partial<Record<string, any>>> | undefined) => import("../../index.js").BlockSpec<"quote", {
+    readonly backgroundColor: {
+        default: "default";
+    };
+    readonly textColor: {
+        default: "default";
+    };
+}, "inline">;

package/types/src/blocks/Table/block.d.ts

@@ -0,0 +1,21 @@
+import { BlockConfig } from "../../schema/index.js";
+export declare const tablePropSchema: {
+    textColor: {
+        default: "default";
+    };
+};
+export type TableBlockConfig = BlockConfig<"table", {
+    textColor: {
+        default: "default";
+    };
+}, "table">;
+export declare const createTableBlockSpec: () => import("../../index.js").LooseBlockSpec<"table", {
+    textColor: {
+        default: "default";
+    };
+}, "table">;
+declare module "@tiptap/core" {
+    interface NodeConfig {
+        tableRole?: string;
+    }
+}