@prosekit/extensions 0.0.0-next-20230709094459 → 0.0.0-next-20240421132240

package/dist/_tsup-dts-rollup.d.ts

@@ -0,0 +1,889 @@
+import { Attrs } from '@prosekit/pm/model';
+import { BundledLanguage } from 'shiki';
+import { BundledLanguageInfo } from 'shiki';
+import { bundledLanguagesInfo } from 'shiki';
+import { BundledTheme } from 'shiki';
+import { BundledThemeInfo } from 'shiki';
+import { bundledThemesInfo } from 'shiki';
+import { Command } from '@prosekit/pm/state';
+import { CommandArgs } from '@prosekit/core';
+import { DedentListOptions } from 'prosemirror-flat-list';
+import { EditorState } from '@prosekit/pm/state';
+import { Extension } from '@prosekit/core';
+import { ExtensionTyping } from '@prosekit/core';
+import { getHighlighter } from 'shiki/bundle/full';
+import { IndentListOptions } from 'prosemirror-flat-list';
+import { InputRule } from '@prosekit/pm/inputrules';
+import { ListAttributes } from 'prosemirror-flat-list';
+import { ListDOMSerializer } from 'prosemirror-flat-list';
+import { NodeRange } from 'prosemirror-model';
+import { NodeType } from '@prosekit/pm/model';
+import { Options } from 'tsup';
+import { Parser } from 'prosemirror-highlight';
+import { Plugin as Plugin_2 } from '@prosekit/pm/state';
+import { PluginKey } from '@prosekit/pm/state';
+import { ProseMirrorNode } from '@prosekit/pm/model';
+import type { SpecialLanguage } from 'shiki';
+import { ToggleCollapsedOptions } from 'prosemirror-flat-list';
+import { Transaction } from '@prosekit/pm/state';
+import { UnwrapListOptions } from 'prosemirror-flat-list';
+
+declare class AutocompleteRule {
+    readonly regex: RegExp;
+    readonly onMatch: MatchHandler;
+    readonly onLeave?: VoidFunction;
+    readonly canMatch: (options: {
+        state: EditorState;
+    }) => boolean;
+    constructor(options: {
+        regex: RegExp;
+        onEnter: MatchHandler;
+        onLeave?: VoidFunction;
+        canMatch?: (options: {
+            state: EditorState;
+        }) => boolean;
+    });
+}
+export { AutocompleteRule }
+export { AutocompleteRule as AutocompleteRule_alias_1 }
+
+export { BundledLanguage as ShikiBundledLanguage }
+export { BundledLanguage as ShikiBundledLanguage_alias_1 }
+
+export { BundledLanguageInfo as ShikiBundledLanguageInfo }
+export { BundledLanguageInfo as ShikiBundledLanguageInfo_alias_1 }
+
+export { bundledLanguagesInfo as shikiBundledLanguagesInfo }
+export { bundledLanguagesInfo as shikiBundledLanguagesInfo_alias_1 }
+
+export { BundledTheme as ShikiBundledTheme }
+export { BundledTheme as ShikiBundledTheme_alias_1 }
+
+export { BundledThemeInfo as ShikiBundledThemeInfo }
+export { BundledThemeInfo as ShikiBundledThemeInfo_alias_1 }
+
+export { bundledThemesInfo as shikiBundledThemesInfo }
+export { bundledThemesInfo as shikiBundledThemesInfo_alias_1 }
+
+export declare interface CellAttrs {
+    colspan: number;
+    rowspan: number;
+    colwidth: number[] | null;
+}
+
+/**
+ * The attributes for the `codeBlock` node.
+ *
+ * @public
+ */
+declare interface CodeBlockAttrs {
+    language?: string;
+}
+export { CodeBlockAttrs }
+export { CodeBlockAttrs as CodeBlockAttrs_alias_1 }
+
+/**
+ * @public
+ */
+export declare interface CodeBlockShikiOptions {
+    /**
+     * Theme registation
+     *
+     * @default ['one-dark-pro']
+     */
+    themes?: BundledTheme[];
+    /**
+     * Language registation
+     *
+     * @default ['text']
+     */
+    langs?: (BundledLanguage | SpecialLanguage)[];
+    /**
+     * Alias of languages
+     *
+     * @example { 'my-lang': 'javascript' }
+     */
+    langAlias?: Record<string, BundledLanguage>;
+}
+
+export declare function createAutocompletePlugin({ getRules, }: {
+    getRules: () => AutocompleteRule[];
+}): Plugin_2;
+
+/**
+ * @internal
+ */
+export declare function createLazyParser(highlighterOptions: HighlighterOptions): Parser;
+
+export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
+
+export declare const default_alias_1: {
+    test: {
+        environment: "jsdom";
+    };
+};
+
+export declare function defaultCanMatch({ state }: {
+    state: EditorState;
+}): boolean;
+
+export declare function defineAutocomplete(rule: AutocompleteRule): Extension;
+
+/**
+ * @public
+ */
+export declare function defineBlockquote(): Extension<    {
+NODES: "blockquote";
+}>;
+
+/**
+ * Wraps the text block in a blockquote when `>` is typed at the start of a new
+ * line followed by a space.
+ */
+export declare function defineBlockquoteInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineBlockquoteSpec(): Extension<    {
+NODES: "blockquote";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineBold(): Extension<    {
+MARKS: "bold";
+COMMAND_ARGS: {
+toggleBold: [];
+};
+}>;
+
+export declare function defineBoldCommands(): Extension<    {
+COMMAND_ARGS: {
+toggleBold: [];
+};
+}>;
+
+export declare function defineBoldKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineBoldSpec(): Extension<    {
+MARKS: "bold";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineCode(): Extension<    {
+MARKS: "code";
+COMMAND_ARGS: {
+toggleCode: [];
+};
+}>;
+
+/**
+ * Adds `codeBlock` nodes to the editor. This includes the following extensions:
+ *
+ * - {@link defineCodeBlockSpec}
+ * - {@link defineCodeBlockInputRule}
+ * - {@link defineCodeBlockEnterRule}
+ * - {@link defineCodeBlockKeymap}
+ * - {@link defineCodeBlockCommands}.
+ *
+ * @public
+ */
+declare function defineCodeBlock(): Extension<    {
+NODES: "codeBlock";
+COMMAND_ARGS: {
+setCodeBlock: [attrs?: CodeBlockAttrs | undefined];
+insertCodeBlock: [attrs?: CodeBlockAttrs | undefined];
+toggleCodeBlock: [attrs?: CodeBlockAttrs | undefined];
+setCodeBlockAttrs: [attrs: CodeBlockAttrs];
+};
+}>;
+export { defineCodeBlock }
+export { defineCodeBlock as defineCodeBlock_alias_1 }
+
+/**
+ * Adds commands for working with `codeBlock` nodes.
+ *
+ * @public
+ */
+declare function defineCodeBlockCommands(): Extension<    {
+COMMAND_ARGS: {
+setCodeBlock: [attrs?: CodeBlockAttrs | undefined];
+insertCodeBlock: [attrs?: CodeBlockAttrs | undefined];
+toggleCodeBlock: [attrs?: CodeBlockAttrs | undefined];
+setCodeBlockAttrs: [attrs: CodeBlockAttrs];
+};
+}>;
+export { defineCodeBlockCommands }
+export { defineCodeBlockCommands as defineCodeBlockCommands_alias_1 }
+
+/**
+ * Adds enter rules for `codeBlock` nodes.
+ *
+ * @public
+ */
+declare function defineCodeBlockEnterRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineCodeBlockEnterRule }
+export { defineCodeBlockEnterRule as defineCodeBlockEnterRule_alias_1 }
+
+/**
+ * Adds syntax highlighting to code blocks. This function requires a `Parser`
+ * instance from the `prosemirror-highlight` package. See the
+ * [documentation](https://github.com/ocavue/prosemirror-highlight) for more
+ * information.
+ *
+ * @public
+ */
+declare function defineCodeBlockHighlight({ parser, }: {
+    parser: HighlightParser;
+}): Extension;
+export { defineCodeBlockHighlight }
+export { defineCodeBlockHighlight as defineCodeBlockHighlight_alias_1 }
+
+/**
+ * Adds input rules for `codeBlock` nodes.
+ *
+ * @public
+ */
+declare function defineCodeBlockInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineCodeBlockInputRule }
+export { defineCodeBlockInputRule as defineCodeBlockInputRule_alias_1 }
+
+/**
+ * Defines the keymap for code blocks.
+ */
+export declare function defineCodeBlockKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+/**
+ * Adds syntax highlighting to code blocks using the [shiki](https://github.com/shikijs/shiki) package.
+ *
+ * @public
+ */
+declare function defineCodeBlockShiki({ themes, langs, langAlias, }?: CodeBlockShikiOptions): Extension;
+export { defineCodeBlockShiki }
+export { defineCodeBlockShiki as defineCodeBlockShiki_alias_1 }
+
+/**
+ * Defines the `codeBlock` node spec.
+ *
+ * @public
+ */
+declare function defineCodeBlockSpec(): Extension<    {
+NODES: "codeBlock";
+}>;
+export { defineCodeBlockSpec }
+export { defineCodeBlockSpec as defineCodeBlockSpec_alias_1 }
+
+export declare function defineCodeCommands(): Extension<    {
+COMMAND_ARGS: {
+toggleCode: [];
+};
+}>;
+
+/**
+ * @public
+ */
+export declare function defineCodeSpec(): Extension<    {
+MARKS: "code";
+}>;
+
+/**
+ * Show up a decoration at the drop position when something is dragged over the editor.
+ *
+ * See [prosemirror-dropcursor](https://github.com/ProseMirror/prosemirror-dropcursor) for more information.
+ *
+ * @public
+ */
+export declare function defineDropCursor(options?: DropCursorOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+/**
+ * Defines an enter rule. An enter rule applies when the text directly in front of
+ * the cursor matches `regex` and user presses Enter. The `regex` should end
+ * with `$`.
+ *
+ * @public
+ */
+export declare function defineEnterRule({ regex, handler, stop, }: EnterRuleOptions): Extension;
+
+/**
+ * @public
+ */
+export declare function defineHeading(): Extension<    {
+NODES: "heading";
+COMMAND_ARGS: {
+setHeading: [attrs?: HeadingAttrs | undefined];
+insertHeading: [attrs?: HeadingAttrs | undefined];
+toggleHeading: [attrs?: HeadingAttrs | undefined];
+};
+}>;
+
+export declare function defineHeadingCommands(): Extension<    {
+COMMAND_ARGS: {
+setHeading: [attrs?: HeadingAttrs | undefined];
+insertHeading: [attrs?: HeadingAttrs | undefined];
+toggleHeading: [attrs?: HeadingAttrs | undefined];
+};
+}>;
+
+/**
+ * Converts the text block to a heading when `#` is typed at the start of a new
+ * line followed by a space.
+ */
+export declare function defineHeadingInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineHeadingKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineHeadingSpec(): Extension<    {
+NODES: "heading";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineImage(): Extension<    {
+NODES: "image";
+COMMAND_ARGS: {
+insertImage: [attrs?: ImageAttrs | undefined];
+};
+}>;
+
+export declare function defineImageCommands(): Extension<    {
+COMMAND_ARGS: {
+insertImage: [attrs?: ImageAttrs | undefined];
+};
+}>;
+
+export declare function defineImageSpec(): Extension<    {
+NODES: "image";
+}>;
+
+/**
+ * Defines an input rule extension.
+ *
+ * @param rule - The ProseMirror input rule to add.
+ *
+ * @public
+ */
+export declare function defineInputRule(rule: InputRule): Extension;
+
+/**
+ * @public
+ */
+export declare function defineItalic(): Extension<    {
+MARKS: "italic";
+COMMAND_ARGS: {
+toggleItalic: [];
+};
+}>;
+
+export declare function defineItalicCommands(): Extension<    {
+COMMAND_ARGS: {
+toggleItalic: [];
+};
+}>;
+
+export declare function defineItalicKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineItalicKeymap_alias_1(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineItalicSpec(): Extension<    {
+MARKS: "italic";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineLink(): Extension<    {
+MARKS: "link";
+COMMAND_ARGS: {
+addLink: [attrs: LinkAttrs];
+removeLink: [];
+toggleLink: [attrs: LinkAttrs];
+expandLink: [];
+};
+}>;
+
+export declare function defineLinkCommands(): Extension<    {
+COMMAND_ARGS: {
+addLink: [attrs: LinkAttrs];
+removeLink: [];
+toggleLink: [attrs: LinkAttrs];
+expandLink: [];
+};
+}>;
+
+export declare function defineLinkEnterRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineLinkInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineLinkSpec(): Extension<    {
+MARKS: "link";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineList(): Extension<{
+    NODES: "list";
+    COMMAND_ARGS: {
+        dedentList: [options?: DedentListOptions | undefined];
+        indentList: [options?: IndentListOptions | undefined];
+        moveList: [direction: "up" | "down"];
+        splitList: [];
+        toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
+        toggleList: [attrs: ListAttributes];
+        unwrapList: [options?: UnwrapListOptions | undefined];
+        wrapInList: [getAttrs: ListAttributes | ((range: NodeRange) => ListAttributes | null)];
+        insertList: [attrs?: ListAttributes | undefined];
+    };
+}>;
+
+export declare function defineListCommands(): Extension<{
+    COMMAND_ARGS: {
+        dedentList: [options?: DedentListOptions | undefined];
+        indentList: [options?: IndentListOptions | undefined];
+        moveList: [direction: "up" | "down"];
+        splitList: [];
+        toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
+        toggleList: [attrs: ListAttributes];
+        unwrapList: [options?: UnwrapListOptions | undefined];
+        wrapInList: [getAttrs: ListAttributes | ((range: NodeRange) => ListAttributes | null)];
+        insertList: [attrs?: ListAttributes | undefined];
+    };
+}>;
+
+export declare function defineListInputRules(): Extension;
+
+/**
+ * Returns a extension that adds key bindings for list.
+ *
+ * @public
+ */
+export declare function defineListKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineListPlugins(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineListSpec(): Extension<{
+    NODES: "list";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineMention(): Extension<    {
+NODES: "mention";
+COMMAND_ARGS: {
+insertMention: [attrs: MentionAttrs];
+};
+}>;
+
+export declare function defineMentionCommands(): Extension<    {
+COMMAND_ARGS: {
+insertMention: [attrs: MentionAttrs];
+};
+}>;
+
+/**
+ * @public
+ */
+export declare function defineMentionSpec(): Extension<    {
+NODES: "mention";
+}>;
+
+/**
+ * Add a placeholder text to the editor when the current block or document is
+ * empty.
+ */
+export declare function definePlaceholder(options: PlaceholderOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+/**
+ * Make the editor read-only.
+ */
+export declare function defineReadonly(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+/**
+ * @public
+ */
+export declare function defineStrike(): Extension<    {
+MARKS: "strike";
+COMMAND_ARGS: {
+toggleStrike: [];
+};
+}>;
+
+export declare function defineStrikeCommands(): Extension<    {
+COMMAND_ARGS: {
+toggleStrike: [];
+};
+}>;
+
+export declare function defineStrikeKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineStrikeSpec(): Extension<    {
+MARKS: "strike";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineTable(): Extension<    {
+NODES: "table" | "tableRow" | "tableCell" | "tableHeaderCell";
+COMMAND_ARGS: {
+insertTable: [{
+row: number;
+col: number;
+header: boolean;
+}];
+exitTable: [];
+};
+}>;
+
+declare function defineTableCellSpec(): Extension<    {
+NODES: "tableCell";
+}>;
+export { defineTableCellSpec }
+export { defineTableCellSpec as defineTableCellSpec_alias_1 }
+
+/**
+ * Adds commands for working with `table` nodes.
+ *
+ * @public
+ */
+declare function defineTableCommands(): Extension<    {
+COMMAND_ARGS: {
+insertTable: [{
+row: number;
+col: number;
+header: boolean;
+}];
+exitTable: [];
+};
+}>;
+export { defineTableCommands }
+export { defineTableCommands as defineTableCommands_alias_1 }
+
+declare function defineTableHeaderCellSpec(): Extension<    {
+NODES: "tableHeaderCell";
+}>;
+export { defineTableHeaderCellSpec }
+export { defineTableHeaderCellSpec as defineTableHeaderCellSpec_alias_1 }
+
+/**
+ * @public
+ */
+declare function defineTablePlugins(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineTablePlugins }
+export { defineTablePlugins as defineTablePlugins_alias_1 }
+
+declare function defineTableRowSpec(): Extension<    {
+NODES: "tableRow";
+}>;
+export { defineTableRowSpec }
+export { defineTableRowSpec as defineTableRowSpec_alias_1 }
+
+declare function defineTableSpec(): Extension<    {
+NODES: "table";
+}>;
+export { defineTableSpec }
+export { defineTableSpec as defineTableSpec_alias_1 }
+
+/**
+ * Defines an enter rule that replaces the matched text with a block node.
+ *
+ * See also {@link defineEnterRule}.
+ *
+ * @public
+ */
+export declare function defineTextBlockEnterRule({ regex, type, attrs, stop, }: TextBlockEnterRuleOptions): Extension;
+
+/**
+ * Defines an input rule that changes the type of a textblock when the matched
+ * text is typed into it.
+ *
+ * See also [textblockTypeInputRule](https://prosemirror.net/docs/ref/#inputrules.textblockTypeInputRule)
+ *
+ * @public
+ */
+export declare function defineTextBlockInputRule({ regex, type, attrs, }: {
+    /**
+     * The regular expression to match against. You'll usually want to start it
+     * with `^` to that it is only matched at the start of a textblock.
+     */
+    regex: RegExp;
+    /**
+     * The node type to replace the matched text with.
+     */
+    type: string | NodeType;
+    /**
+     * Attributes to set on the node.
+     */
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+}): Extension;
+
+/**
+ * @public
+ */
+export declare function defineUnderline(): Extension<    {
+MARKS: "underline";
+COMMAND_ARGS: {
+toggleUnderline: [];
+};
+}>;
+
+export declare function defineUnderlineCommands(): Extension<    {
+COMMAND_ARGS: {
+toggleUnderline: [];
+};
+}>;
+
+export declare function defineUnderlineKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineUnderlineSpec(): Extension<    {
+MARKS: "underline";
+}>;
+
+/**
+ * Shows a virtual selection when the editor is not focused. When the editor is
+ * not focused, the selected inline content will be wrapped in a `<span>`
+ * element with the class `prosekit-virtual-selection`.
+ *
+ * This is useful when you want to move the focus to an element outside the
+ * editor, but still want to show the selection.
+ *
+ * @public
+ */
+export declare function defineVirtualSelection(): Extension;
+
+/**
+ * Defines an input rule for automatically wrapping a textblock when a given
+ * string is typed.
+ *
+ * See also [wrappingInputRule](https://prosemirror.net/docs/ref/#inputrules.wrappingInputRule)
+ *
+ * @public
+ */
+export declare function defineWrappingInputRule({ regex, type, attrs, join, }: {
+    /**
+     * The regular expression to match against. You'll usually want to start it
+     * with `^` to that it is only matched at the start of a textblock.
+     */
+    regex: RegExp;
+    /**
+     * The type of node to wrap in.
+     */
+    type: string | NodeType;
+    /**
+     * Attributes to set on the node.
+     */
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+    /**
+     * By default, if there's a node with the same type above the newly wrapped
+     * node, the rule will try to
+     * [join](https://prosemirror.net/docs/ref/#transform.Transform.join) those
+     * two nodes. You can pass a join predicate, which takes a regular expression
+     * match and the node before the wrapped node, and can return a boolean to
+     * indicate whether a join should happen.
+     */
+    join?: (match: RegExpMatchArray, node: ProseMirrorNode) => boolean;
+}): Extension;
+
+export declare interface DropCursorOptions {
+    /**
+     * The color of the cursor.  Use `false` to apply no color and rely only on class.
+     *
+     * @default 'black'
+     */
+    color?: string | false;
+    /**
+     * The precise width of the cursor in pixels.
+     *
+     * @default 1
+     */
+    width?: number;
+    /**
+     * A CSS class name to add to the cursor element.
+     */
+    class?: string;
+}
+
+/**
+ * @public
+ */
+export declare type EnterRuleHandler = (options: {
+    /**
+     * The current editor state.
+     */
+    state: EditorState;
+    /**
+     * The start position of the matched text.
+     */
+    from: number;
+    /**
+     * The end position of the matched text.
+     */
+    to: number;
+    /**
+     * The matched result from the regular expression.
+     */
+    match: RegExpExecArray;
+}) => Transaction | null;
+
+/**
+ * Options for {@link defineEnterRule}.
+ *
+ * @public
+ */
+export declare type EnterRuleOptions = {
+    /**
+     * The regular expression to match against. It should end with `$`.
+     */
+    regex: RegExp;
+    /**
+     * A function to be called when an enter rule is triggered.
+     */
+    handler: EnterRuleHandler;
+    /**
+     * Whether to stop further handlers from being called if this rule is triggered.
+     *
+     * @default false
+     */
+    stop?: boolean;
+};
+
+/**
+ * When the selection is in a table node, create a default block after the table
+ * table, and move the cursor there.
+ *
+ * @public
+ */
+export declare const exitTable: Command;
+
+export { getHighlighter }
+
+export declare function getPluginState(state: EditorState): PredictionPluginState | undefined;
+
+export declare function getTrMeta(tr: Transaction): PredictionPluginState;
+
+export declare interface HeadingAttrs {
+    level: number;
+}
+
+declare type HighlighterOptions = {
+    themes: BundledTheme[];
+    langs: (BundledLanguage | SpecialLanguage)[];
+    langAlias?: Record<string, BundledLanguage>;
+};
+
+/**
+ * @public
+ *
+ * An alias for the `Parser` type from the `prosemirror-highlight` package.
+ */
+declare type HighlightParser = Parser;
+export { HighlightParser }
+export { HighlightParser as HighlightParser_alias_1 }
+
+export declare interface ImageAttrs {
+    src?: string | null;
+}
+
+/**
+ * Insert a table node with the given number of rows and columns, and optionally
+ * a header row.
+ *
+ * @public
+ */
+export declare function insertTable({ row, col, header, }: {
+    row: number;
+    col: number;
+    header: boolean;
+}): Command;
+
+export declare const LINK_RE: RegExp;
+
+export declare const LINK_SPACE_RE: RegExp;
+
+/**
+ * @public
+ */
+export declare interface LinkAttrs {
+    href: string;
+}
+
+export { ListDOMSerializer }
+
+declare type MatchHandler = (options: {
+    state: EditorState;
+    match: RegExpExecArray;
+    from: number;
+    to: number;
+    ignoreMatch: () => void;
+    deleteMatch: () => void;
+}) => void;
+export { MatchHandler }
+export { MatchHandler as MatchHandler_alias_1 }
+
+export declare interface MentionAttrs {
+    id: string;
+    kind: string;
+    value: string;
+}
+
+export declare interface PlaceholderOptions {
+    /**
+     * The placeholder text to use.
+     */
+    placeholder: string;
+    /**
+     * By default, the placeholder text will be shown whenever the current text
+     * cursor is in an empty text node. If you only want to show the placeholder
+     * when the whole doc is empty, you can set this option to 'doc'.
+     *
+     * @default 'block'
+     */
+    strategy?: 'doc' | 'block';
+}
+
+export declare const pluginKey: PluginKey<PredictionPluginState>;
+
+export declare interface PredictionPluginState {
+    active: boolean;
+    ignore: number | null;
+    matching: {
+        rule: AutocompleteRule;
+        from: number;
+        to: number;
+        match: RegExpExecArray;
+    } | null;
+}
+
+export declare function setTrMeta(tr: Transaction, meta: PredictionPluginState): Transaction;
+
+/**
+ * Options for {@link defineTextBlockEnterRule}.
+ *
+ * @public
+ */
+export declare type TextBlockEnterRuleOptions = {
+    /**
+     * The regular expression to match against. It should end with `$`.
+     */
+    regex: RegExp;
+    /**
+     * The node type to replace the matched text with.
+     */
+    type: string | NodeType;
+    /**
+     * Attributes to set on the node. If a function is provided, it will be called
+     * with the matched result from the regular expression.
+     */
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+    /**
+     * Whether to stop further handlers from being called if this rule is triggered.
+     *
+     * @default true
+     */
+    stop?: boolean;
+};
+
+export { }