@licium/editor 3.2.3

package/dist/esm/i18n/viewer.d.ts

@@ -0,0 +1,77 @@
+import { ViewerOptions } from '@t/editor';
+import { Handler } from '@t/event';
+/**
+ * Class ToastUIEditorViewer
+ * @param {object} options Option object
+ *     @param {HTMLElement} options.el - container element
+ *     @param {string} [options.initialValue] Editor's initial value
+ *     @param {Object} [options.events] - Events
+ *         @param {function} [options.events.load] - It would be emitted when editor fully load
+ *         @param {function} [options.events.change] - It would be emitted when content changed
+ *         @param {function} [options.events.caretChange] - It would be emitted when format change by cursor position
+ *         @param {function} [options.events.focus] - It would be emitted when editor get focus
+ *         @param {function} [options.events.blur] - It would be emitted when editor loose focus
+ *     @param {Array.<function|Array>} [options.plugins] - Array of plugins. A plugin can be either a function or an array in the form of [function, options].
+ *     @param {Object} [options.extendedAutolinks] - Using extended Autolinks specified in GFM spec
+ *     @param {Object} [options.linkAttributes] - Attributes of anchor element that should be rel, target, hreflang, type
+ *     @param {Object} [options.customHTMLRenderer=null] - Object containing custom renderer functions correspond to change markdown node to preview HTML or wysiwyg node
+ *     @param {boolean} [options.referenceDefinition=false] - whether use the specification of link reference definition
+ *     @param {function} [options.customHTMLSanitizer=null] - custom HTML sanitizer
+ *     @param {boolean} [options.frontMatter=false] - whether use the front matter
+ *     @param {string} [options.theme] - The theme to style the viewer with. The default is included in toastui-editor.css.
+ */
+declare class ToastUIEditorViewer {
+    private options;
+    private toastMark;
+    private eventEmitter;
+    private preview;
+    constructor(options: ViewerOptions);
+    /**
+     * Toggle task by detecting mousedown event.
+     * @param {MouseEvent} ev - event
+     * @private
+     */
+    private toggleTask;
+    /**
+     * Set content for preview
+     * @param {string} markdown Markdown text
+     */
+    setMarkdown(markdown: string): void;
+    /**
+     * Bind eventHandler to event type
+     * @param {string} type Event type
+     * @param {function} handler Event handler
+     */
+    on(type: string, handler: Handler): void;
+    /**
+     * Unbind eventHandler from event type
+     * @param {string} type Event type
+     */
+    off(type: string): void;
+    /**
+     * Add hook to TUIEditor event
+     * @param {string} type Event type
+     * @param {function} handler Event handler
+     */
+    addHook(type: string, handler: Handler): void;
+    /**
+     * Remove Viewer preview from document
+     */
+    destroy(): void;
+    /**
+     * Return true
+     * @returns {boolean}
+     */
+    isViewer(): boolean;
+    /**
+     * Return false
+     * @returns {boolean}
+     */
+    isMarkdownMode(): boolean;
+    /**
+     * Return false
+     * @returns {boolean}
+     */
+    isWysiwygMode(): boolean;
+}
+export default ToastUIEditorViewer;

package/dist/esm/i18n/widget/rules.d.ts

@@ -0,0 +1,28 @@
+import { Schema } from 'prosemirror-model';
+import { CustomInlineMdNode } from '@licium/toastmark';
+import { WidgetRule } from '@t/editor';
+export declare function unwrapWidgetSyntax(text: string): string;
+export declare function createWidgetContent(info: string, text: string): string;
+export declare function widgetToDOM(info: string, text: string): HTMLElement;
+export declare function getWidgetRules(): WidgetRule[];
+export declare function setWidgetRules(rules: WidgetRule[]): void;
+/**
+ * create nodes with plain text and replace text matched to the widget rules with the widget node
+ * For example, in case the text and widget rules as below
+ *
+ * text: $test plain text #test
+ * widget rules: [{ rule: /$.+/ }, { rule: /#.+/ }]
+ *
+ * The creating node process is recursive and is as follows.
+ *
+ * in first widget rule(/$.+/)
+ *  $test -> widget node
+ *  plain text -> match with next widget rule
+ *  #test -> match with next widget rule
+ *
+ * in second widget rule(/#.+/)
+ *  plain text -> text node(no rule for matching)
+ *  #test -> widget node
+ */
+export declare function createNodesWithWidget(text: string, schema: Schema, ruleIndex?: number): import("prosemirror-model").Node[];
+export declare function getWidgetContent(widgetNode: CustomInlineMdNode): string;

package/dist/esm/i18n/widget/widgetNode.d.ts

@@ -0,0 +1,28 @@
+import { DOMOutputSpec, ProsemirrorNode } from 'prosemirror-model';
+import SpecNode from '@/spec/node';
+export declare function widgetNodeView(pmNode: ProsemirrorNode): {
+    dom: HTMLSpanElement;
+};
+export declare function isWidgetNode(pmNode: ProsemirrorNode): boolean;
+export declare class Widget extends SpecNode {
+    get name(): string;
+    get schema(): {
+        attrs: {
+            info: {
+                default: null;
+            };
+        };
+        group: string;
+        inline: boolean;
+        content: string;
+        selectable: boolean;
+        atom: boolean;
+        toDOM(): DOMOutputSpec;
+        parseDOM: {
+            tag: string;
+            getAttrs(dom: Node | string): {
+                info: string;
+            };
+        }[];
+    };
+}

package/dist/esm/i18n/wysiwyg/adaptor/mdLikeNode.d.ts

@@ -0,0 +1,5 @@
+import { Mark, Node as ProsemirrorNode } from 'prosemirror-model';
+import { MdLikeNode } from '@t/markdown';
+export declare function isPmNode(node: ProsemirrorNode | Mark): node is ProsemirrorNode;
+export declare function isContainer(type: string): boolean;
+export declare function createMdLikeNode(node: ProsemirrorNode | Mark): MdLikeNode;

package/dist/esm/i18n/wysiwyg/adaptor/wwToDOMAdaptor.d.ts

@@ -0,0 +1,13 @@
+import { HTMLConvertorMap, Renderer } from '@licium/toastmark';
+import { Mark } from 'prosemirror-model';
+import { ToDOMAdaptor } from '@t/convertor';
+import { CustomHTMLRenderer, LinkAttributes } from '@t/editor';
+export declare class WwToDOMAdaptor implements ToDOMAdaptor {
+    private customConvertorKeys;
+    renderer: Renderer;
+    convertors: HTMLConvertorMap;
+    constructor(linkAttributes: LinkAttributes | null, customRenderer: CustomHTMLRenderer);
+    private generateTokens;
+    private toDOMNode;
+    getToDOMNode(name: string): ((node: import("prosemirror-model").Node | Mark) => HTMLElement) | null;
+}

package/dist/esm/i18n/wysiwyg/clipboard/paste.d.ts

@@ -0,0 +1,6 @@
+import { Schema, Node, Slice, Fragment } from 'prosemirror-model';
+export declare function changePastedHTML(html: string): string;
+export declare function copyTableHeadRow(orgRow: Node, maxColumnCount: number, schema: Schema): Node;
+export declare function copyTableBodyRow(orgRow: Node, maxColumnCount: number, schema: Schema): Node;
+export declare function createRowsFromPastingTable(tableContent: Fragment): Node[];
+export declare function changePastedSlice(slice: Slice, schema: Schema, isInTable: boolean): Slice;

package/dist/esm/i18n/wysiwyg/clipboard/pasteMsoList.d.ts

@@ -0,0 +1,2 @@
+export declare function isFromMso(html: string): boolean;
+export declare function convertMsoParagraphsToList(html: string): string;

package/dist/esm/i18n/wysiwyg/clipboard/pasteTextParser.d.ts

@@ -0,0 +1,2 @@
+import { Slice, ResolvedPos } from 'prosemirror-model';
+export declare function clipboardTextParser(text: string, $context: ResolvedPos): Slice;

package/dist/esm/i18n/wysiwyg/clipboard/pasteToTable.d.ts

@@ -0,0 +1,3 @@
+import { Slice } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+export declare function pasteToTable(view: EditorView, slice: Slice): boolean;

package/dist/esm/i18n/wysiwyg/command/list.d.ts

@@ -0,0 +1,7 @@
+import { NodeType } from 'prosemirror-model';
+import { Command } from 'prosemirror-state';
+export declare function changeList(list: NodeType): Command;
+export declare function toggleTask(): Command;
+export declare function sinkListItem(listItem: NodeType): Command;
+export declare function liftListItem(listItem: NodeType): Command;
+export declare function splitListItem(listItem: NodeType): Command;

package/dist/esm/i18n/wysiwyg/command/table.d.ts

@@ -0,0 +1,16 @@
+import { ProsemirrorNode, ResolvedPos, Schema } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+import { TableOffsetMap } from '../helper/tableOffsetMap';
+import { Direction } from '../nodes/table';
+export declare type CellPosition = [rowIdx: number, colIdx: number];
+export declare function canMoveBetweenCells(direction: Direction, [cellDepth, paraDepth]: number[], from: ResolvedPos, doc: ProsemirrorNode): boolean;
+export declare function canBeOutOfTable(direction: Direction, map: TableOffsetMap, [rowIdx, colIdx]: CellPosition): boolean;
+export declare function addParagraphBeforeTable(tr: Transaction, map: TableOffsetMap, schema: Schema): Transaction;
+export declare function addParagraphAfterTable(tr: Transaction, map: TableOffsetMap, schema: Schema, forcedAddtion?: boolean): Transaction;
+export declare function getRightCellOffset([rowIdx, colIdx]: CellPosition, map: TableOffsetMap): number | null;
+export declare function getLeftCellOffset([rowIdx, colIdx]: CellPosition, map: TableOffsetMap): number | null;
+export declare function getUpCellOffset([rowIdx, colIdx]: CellPosition, map: TableOffsetMap): number | null;
+export declare function getDownCellOffset([rowIdx, colIdx]: CellPosition, map: TableOffsetMap): number | null;
+export declare function moveToCell(direction: Direction, tr: Transaction, cellIndex: CellPosition, map: TableOffsetMap): Transaction | null;
+export declare function canSelectTableNode(direction: Direction, map: TableOffsetMap, [rowIdx, colIdx]: CellPosition): boolean;
+export declare function selectNode(tr: Transaction, pos: ResolvedPos, depth: number): Transaction;

package/dist/esm/i18n/wysiwyg/helper/node.d.ts

@@ -0,0 +1,37 @@
+import { ProsemirrorNode, ResolvedPos } from 'prosemirror-model';
+declare type NodeAttrs = Record<string, any>;
+interface CustomAttrs {
+    htmlAttrs: {
+        default: any;
+    };
+    classNames: {
+        default: null | string[];
+    };
+}
+export declare function findNodeBy(pos: ResolvedPos, condition: (node: ProsemirrorNode, depth: number) => boolean): {
+    node: import("prosemirror-model").Node;
+    depth: number;
+    offset: number;
+} | null;
+export declare function isListNode({ type }: ProsemirrorNode): boolean;
+export declare function isInListNode(pos: ResolvedPos): boolean;
+export declare function isInTableNode(pos: ResolvedPos): boolean;
+export declare function findListItem(pos: ResolvedPos): {
+    node: import("prosemirror-model").Node;
+    depth: number;
+    offset: number;
+} | null;
+export declare function createDOMInfoParsedRawHTML(tag: string): {
+    tag: string;
+    getAttrs(dom: Node | string): {
+        rawHTML?: string | undefined;
+    };
+};
+export declare function createCellAttrs(attrs: NodeAttrs): NodeAttrs;
+export declare function createParsedCellDOM(tag: string): {
+    tag: string;
+    getAttrs(dom: Node | string): NodeAttrs;
+};
+export declare function getDefaultCustomAttrs(): CustomAttrs;
+export declare function getCustomAttrs(attrs: Record<string, any>): any;
+export {};

package/dist/esm/i18n/wysiwyg/helper/table.d.ts

@@ -0,0 +1,25 @@
+import { Node, Schema, ResolvedPos, Slice, ProsemirrorNode } from 'prosemirror-model';
+import { Selection } from 'prosemirror-state';
+import { CellSelection } from '@t/wysiwyg';
+import type { SelectionInfo } from './tableOffsetMap';
+export declare function createTableHeadRow(columnCount: number, schema: Schema, data?: string[]): Node[];
+export declare function createTableBodyRows(rowCount: number, columnCount: number, schema: Schema, data?: string[]): Node[];
+export declare function createDummyCells(columnCount: number, rowIdx: number, schema: Schema, attrs?: Record<string, any> | null): Node[];
+export declare function findCellElement(node: HTMLElement, root: Element): HTMLElement | null;
+export declare function findCell(pos: ResolvedPos): {
+    node: Node;
+    depth: number;
+    offset: number;
+} | null;
+export declare function getResolvedSelection(selection: Selection | CellSelection): {
+    anchor: ResolvedPos;
+    head: ResolvedPos;
+};
+export declare function getTableContentFromSlice(slice: Slice): import("prosemirror-model").Fragment | null;
+export declare function getRowAndColumnCount({ startRowIdx, startColIdx, endRowIdx, endColIdx, }: SelectionInfo): {
+    rowCount: number;
+    columnCount: number;
+};
+export declare function setAttrs(cell: ProsemirrorNode, attrs: Record<string, any>): {
+    [x: string]: any;
+};

package/dist/esm/i18n/wysiwyg/helper/tableOffsetMap.d.ts

@@ -0,0 +1,88 @@
+import type { Node, ResolvedPos } from 'prosemirror-model';
+export interface CellInfo {
+    offset: number;
+    nodeSize: number;
+    extended?: boolean;
+}
+export interface SelectionInfo {
+    startRowIdx: number;
+    startColIdx: number;
+    endRowIdx: number;
+    endColIdx: number;
+}
+interface SpanMap {
+    [key: number]: {
+        count: number;
+        startSpanIdx: number;
+    };
+}
+export interface RowInfo {
+    [key: number]: CellInfo;
+    length: number;
+    rowspanMap: SpanMap;
+    colspanMap: SpanMap;
+}
+interface SpanInfo {
+    node: Node;
+    pos: number;
+    count: number;
+    startSpanIdx: number;
+}
+interface OffsetMap {
+    rowInfo: RowInfo[];
+    table: Node;
+    totalRowCount: number;
+    totalColumnCount: number;
+    tableStartOffset: number;
+    tableEndOffset: number;
+    getCellInfo(rowIdx: number, colIdx: number): CellInfo;
+    posAt(rowIdx: number, colIdx: number): number;
+    getNodeAndPos(rowIdx: number, colIdx: number): {
+        node: Node;
+        pos: number;
+    };
+    extendedRowspan(rowIdx: number, colIdx: number): boolean;
+    extendedColspan(rowIdx: number, colIdx: number): boolean;
+    getRowspanCount(rowIdx: number, colIdx: number): number;
+    getColspanCount(rowIdx: number, colIdx: number): number;
+    decreaseColspanCount(rowIdx: number, colIdx: number): number;
+    decreaseRowspanCount(rowIdx: number, colIdx: number): number;
+    getColspanStartInfo(rowIdx: number, colIdx: number): SpanInfo | null;
+    getRowspanStartInfo(rowIdx: number, colIdx: number): SpanInfo | null;
+    getRectOffsets(startCellPos: ResolvedPos, endCellPos?: ResolvedPos): SelectionInfo;
+    getSpannedOffsets(selectionInfo: SelectionInfo): SelectionInfo;
+}
+declare type CreateOffsetMapMixin = (headOrBody: Node, startOffset: number, startFromBody?: boolean) => RowInfo[];
+export declare class TableOffsetMap {
+    private table;
+    private tableRows;
+    private tableStartPos;
+    private rowInfo;
+    constructor(table: Node, tableRows: Node[], tableStartPos: number, rowInfo: RowInfo[]);
+    static create(cellPos: ResolvedPos): TableOffsetMap | null;
+    get totalRowCount(): number;
+    get totalColumnCount(): number;
+    get tableStartOffset(): number;
+    get tableEndOffset(): number;
+    getCellInfo(rowIdx: number, colIdx: number): CellInfo;
+    posAt(rowIdx: number, colIdx: number): number;
+    getNodeAndPos(rowIdx: number, colIdx: number): {
+        node: Node;
+        pos: number;
+    };
+    extendedRowspan(rowIdx: number, colIdx: number): boolean;
+    extendedColspan(rowIdx: number, colIdx: number): boolean;
+    getRowspanCount(rowIdx: number, colIdx: number): number;
+    getColspanCount(rowIdx: number, colIdx: number): number;
+    decreaseColspanCount(rowIdx: number, colIdx: number): number;
+    decreaseRowspanCount(rowIdx: number, colIdx: number): number;
+    getColspanStartInfo(rowIdx: number, colIdx: number): SpanInfo | null;
+    getRowspanStartInfo(rowIdx: number, colIdx: number): SpanInfo | null;
+    getCellStartOffset(rowIdx: number, colIdx: number): number;
+    getCellEndOffset(rowIdx: number, colIdx: number): number;
+    getCellIndex(cellPos: ResolvedPos): [rowIdx: number, colIdx: number];
+    getRectOffsets(startCellPos: ResolvedPos, endCellPos?: ResolvedPos): SelectionInfo;
+    getSpannedOffsets(selectionInfo: SelectionInfo): SelectionInfo;
+}
+export declare function mixinTableOffsetMapPrototype(offsetMapMixin: OffsetMap, createOffsetMapMixin: CreateOffsetMapMixin): typeof TableOffsetMap;
+export {};

package/dist/esm/i18n/wysiwyg/markdownInputRules.d.ts

@@ -0,0 +1,3 @@
+import { InputRule } from 'prosemirror-inputrules';
+import { Schema } from 'prosemirror-model';
+export declare function createMarkdownInputRules(schema: Schema): InputRule[];

package/dist/esm/i18n/wysiwyg/marks/code.d.ts

@@ -0,0 +1,31 @@
+import { Mark as ProsemirrorMark, DOMOutputSpec } from 'prosemirror-model';
+import Mark from '@/spec/mark';
+import { EditorCommand } from '@t/spec';
+export declare class Code extends Mark {
+    get name(): string;
+    get schema(): {
+        attrs: {
+            htmlAttrs: {
+                default: any;
+            };
+            classNames: {
+                default: string[] | null;
+            };
+            rawHTML: {
+                default: null;
+            };
+        };
+        parseDOM: {
+            tag: string;
+            getAttrs(dom: Node | string): {
+                rawHTML?: string | undefined;
+            };
+        }[];
+        toDOM({ attrs }: ProsemirrorMark): DOMOutputSpec;
+    };
+    commands(): EditorCommand;
+    keymaps(): {
+        'Shift-Mod-c': import("prosemirror-state").Command;
+        'Shift-Mod-C': import("prosemirror-state").Command;
+    };
+}

package/dist/esm/i18n/wysiwyg/marks/emph.d.ts

@@ -0,0 +1,34 @@
+import { Mark as ProsemirrorMark, DOMOutputSpec } from 'prosemirror-model';
+import Mark from '@/spec/mark';
+import { EditorCommand } from '@t/spec';
+export declare class Emph extends Mark {
+    get name(): string;
+    get schema(): {
+        attrs: {
+            htmlAttrs: {
+                default: any;
+            };
+            classNames: {
+                default: string[] | null;
+            };
+            rawHTML: {
+                default: null;
+            };
+        };
+        parseDOM: {
+            tag: string;
+            getAttrs(dom: Node | string): {
+                rawHTML?: string | undefined;
+            };
+        }[];
+        toDOM({ attrs }: ProsemirrorMark): DOMOutputSpec;
+    };
+    private italic;
+    commands(): {
+        italic: EditorCommand<import("@t/spec").DefaultPayload>;
+    };
+    keymaps(): {
+        'Mod-i': import("prosemirror-state").Command;
+        'Mod-I': import("prosemirror-state").Command;
+    };
+}

package/dist/esm/i18n/wysiwyg/marks/link.d.ts

@@ -0,0 +1,59 @@
+import { Mark as ProsemirrorMark, DOMOutputSpec } from 'prosemirror-model';
+import Mark from '@/spec/mark';
+import { EditorCommand } from '@t/spec';
+import { LinkAttributes } from '@t/editor';
+export declare class Link extends Mark {
+    private linkAttributes;
+    constructor(linkAttributes: LinkAttributes);
+    get name(): string;
+    get schema(): {
+        attrs: {
+            htmlAttrs: {
+                default: any;
+            };
+            classNames: {
+                default: string[] | null;
+            };
+            linkUrl: {
+                default: string;
+            };
+            title: {
+                default: null;
+            };
+            rawHTML: {
+                default: null;
+            };
+            target: {
+                default: null;
+            };
+            rel: {
+                default: null;
+            };
+            class: {
+                default: null;
+            };
+            id: {
+                default: null;
+            };
+        };
+        parseDOM: {
+            tag: string;
+            getAttrs(dom: Node | string): {
+                id?: string | undefined;
+                class?: string | undefined;
+                rel?: string | undefined;
+                target?: string | undefined;
+                rawHTML?: string | undefined;
+                linkUrl: string;
+                title: string;
+            };
+        }[];
+        toDOM: ({ attrs }: ProsemirrorMark) => DOMOutputSpec;
+    };
+    private addLink;
+    private toggleLink;
+    commands(): {
+        addLink: EditorCommand<import("@t/spec").DefaultPayload>;
+        toggleLink: EditorCommand<import("@t/spec").DefaultPayload>;
+    };
+}

package/dist/esm/i18n/wysiwyg/marks/strike.d.ts

@@ -0,0 +1,31 @@
+import { Mark as ProsemirrorMark, DOMOutputSpec } from 'prosemirror-model';
+import Mark from '@/spec/mark';
+import { EditorCommand } from '@t/spec';
+export declare class Strike extends Mark {
+    get name(): string;
+    get schema(): {
+        attrs: {
+            htmlAttrs: {
+                default: any;
+            };
+            classNames: {
+                default: string[] | null;
+            };
+            rawHTML: {
+                default: null;
+            };
+        };
+        parseDOM: {
+            tag: string;
+            getAttrs(dom: Node | string): {
+                rawHTML?: string | undefined;
+            };
+        }[];
+        toDOM({ attrs }: ProsemirrorMark): DOMOutputSpec;
+    };
+    commands(): EditorCommand;
+    keymaps(): {
+        'Mod-s': import("prosemirror-state").Command;
+        'Mod-S': import("prosemirror-state").Command;
+    };
+}

package/dist/esm/i18n/wysiwyg/marks/strong.d.ts

@@ -0,0 +1,34 @@
+import { Mark as ProsemirrorMark, DOMOutputSpec } from 'prosemirror-model';
+import Mark from '@/spec/mark';
+import { EditorCommand } from '@t/spec';
+export declare class Strong extends Mark {
+    get name(): string;
+    get schema(): {
+        attrs: {
+            htmlAttrs: {
+                default: any;
+            };
+            classNames: {
+                default: string[] | null;
+            };
+            rawHTML: {
+                default: null;
+            };
+        };
+        parseDOM: {
+            tag: string;
+            getAttrs(dom: Node | string): {
+                rawHTML?: string | undefined;
+            };
+        }[];
+        toDOM({ attrs }: ProsemirrorMark): DOMOutputSpec;
+    };
+    private bold;
+    commands(): {
+        bold: EditorCommand<import("@t/spec").DefaultPayload>;
+    };
+    keymaps(): {
+        'Mod-b': import("prosemirror-state").Command;
+        'Mod-B': import("prosemirror-state").Command;
+    };
+}

package/dist/esm/i18n/wysiwyg/nodes/blockQuote.d.ts

@@ -0,0 +1,33 @@
+import { DOMOutputSpec, ProsemirrorNode } from 'prosemirror-model';
+import NodeSchema from '@/spec/node';
+import { EditorCommand } from '@t/spec';
+export declare class BlockQuote extends NodeSchema {
+    get name(): string;
+    get schema(): {
+        attrs: {
+            htmlAttrs: {
+                default: any;
+            };
+            classNames: {
+                default: string[] | null;
+            };
+            rawHTML: {
+                default: null;
+            };
+        };
+        content: string;
+        group: string;
+        parseDOM: {
+            tag: string;
+            getAttrs(dom: string | Node): {
+                rawHTML?: string | undefined;
+            };
+        }[];
+        toDOM({ attrs }: ProsemirrorNode): DOMOutputSpec;
+    };
+    commands(): EditorCommand;
+    keymaps(): {
+        'Alt-q': import("prosemirror-state").Command;
+        'Alt-Q': import("prosemirror-state").Command;
+    };
+}

package/dist/esm/i18n/wysiwyg/nodes/bulletList.d.ts

@@ -0,0 +1,43 @@
+import { DOMOutputSpec, ProsemirrorNode } from 'prosemirror-model';
+import NodeSchema from '@/spec/node';
+import { toggleTask } from '@/wysiwyg/command/list';
+import { Command } from 'prosemirror-state';
+export declare class BulletList extends NodeSchema {
+    get name(): string;
+    get schema(): {
+        content: string;
+        group: string;
+        attrs: {
+            htmlAttrs: {
+                default: any;
+            };
+            classNames: {
+                default: string[] | null;
+            };
+            rawHTML: {
+                default: null;
+            };
+            bullet: {
+                default: null;
+            };
+        };
+        parseDOM: {
+            tag: string;
+            getAttrs(dom: string | Node): {
+                rawHTML?: string | undefined;
+            };
+        }[];
+        toDOM({ attrs }: ProsemirrorNode): DOMOutputSpec;
+    };
+    private changeList;
+    commands(): {
+        bulletList: () => Command;
+        taskList: typeof toggleTask;
+    };
+    keymaps(): {
+        'Mod-u': Command;
+        'Mod-U': Command;
+        Tab: Command;
+        'Shift-Tab': Command;
+    };
+}