import { BlockContent } from 'mdast';
import { Blockquote } from 'mdast';
import { Break } from 'mdast';
import { Code } from 'mdast';
import { Command } from 'prosemirror-state';
import { Definition } from 'mdast';
import { DefinitionContent } from 'mdast';
import { Delete } from 'mdast';
import { Emphasis } from 'mdast';
import { Extension } from 'prosemirror-unified';
import { Heading } from 'mdast';
import { Image as Image_2 } from 'mdast';
import { ImageReference } from 'mdast';
import { InlineCode } from 'mdast';
import { InputRule } from 'prosemirror-inputrules';
import { Link } from 'mdast';
import { LinkReference } from 'mdast';
import { List } from 'mdast';
import { ListContent } from 'mdast';
import { ListItem } from 'mdast';
import { Mark } from 'prosemirror-model';
import { MarkExtension } from 'prosemirror-unified';
import { MarkSpec } from 'prosemirror-model';
import { Node as Node_2 } from 'unist';
import { Node as Node_3 } from 'prosemirror-model';
import { NodeExtension } from 'prosemirror-unified';
import { NodeSpec } from 'prosemirror-model';
import { NodeViewConstructor } from 'prosemirror-view';
import { Paragraph } from 'mdast';
import { PhrasingContent } from 'mdast';
import { Processor } from 'unified';
import { Root } from 'mdast';
import { RootContent } from 'mdast';
import { Schema } from 'prosemirror-model';
import { Strong } from 'mdast';
import { Text as Text_2 } from 'mdast';
import { ThematicBreak } from 'mdast';

/**
 * @public
 */
export declare class BlockquoteExtension extends NodeExtension<Blockquote> {
    proseMirrorInputRules(proseMirrorSchema: Schema<string, string>): Array<InputRule>;
    proseMirrorKeymap(proseMirrorSchema: Schema<string, string>): Record<string, Command>;
    proseMirrorNodeName(): string;
    proseMirrorNodeSpec(): NodeSpec;
    proseMirrorNodeToUnistNodes(_node: Node_3, convertedChildren: Array<BlockContent | DefinitionContent>): Array<Blockquote>;
    unistNodeName(): "blockquote";
    unistNodeToProseMirrorNodes(_node: Blockquote, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
}

/**
 * @public
 */
export declare class BoldExtension extends MarkExtension<Strong> {
    processConvertedUnistNode(convertedNode: Emphasis | Text_2): Strong;
    proseMirrorInputRules(proseMirrorSchema: Schema<string, string>): Array<InputRule>;
    proseMirrorKeymap(proseMirrorSchema: Schema<string, string>): Record<string, Command>;
    proseMirrorMarkName(): string;
    proseMirrorMarkSpec(): MarkSpec;
    unistNodeName(): "strong";
    unistNodeToProseMirrorNodes(_node: Strong, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
}

/**
 * @public
 */
export declare class BreakExtension extends NodeExtension<Break> {
    proseMirrorKeymap(proseMirrorSchema: Schema<string, string>): Record<string, Command>;
    proseMirrorNodeName(): string;
    proseMirrorNodeSpec(): NodeSpec;
    proseMirrorNodeToUnistNodes(): Array<Break>;
    unistNodeName(): "break";
    unistNodeToProseMirrorNodes(_node: Break, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
}

/**
 * @public
 */
export declare class CodeBlockExtension extends NodeExtension<Code> {
    private static liftOutOfCodeBlock;
    dependencies(): Array<Extension>;
    proseMirrorInputRules(proseMirrorSchema: Schema<string, string>): Array<InputRule>;
    proseMirrorKeymap(proseMirrorSchema: Schema<string, string>): Record<string, Command>;
    proseMirrorNodeName(): string;
    proseMirrorNodeSpec(): NodeSpec;
    proseMirrorNodeToUnistNodes(_node: Node_3, convertedChildren: Array<Text_2>): Array<Code>;
    unistNodeName(): "code";
    unistNodeToProseMirrorNodes(node: Code, proseMirrorSchema: Schema<string, string>): Array<Node_3>;
}

/**
 * @public
 */
export declare class DefinitionExtension extends NodeExtension<Definition> {
    proseMirrorNodeName(): null;
    proseMirrorNodeSpec(): null;
    proseMirrorNodeToUnistNodes(): Array<Definition>;
    unistNodeName(): "definition";
    unistNodeToProseMirrorNodes(node: Definition, _proseMirrorSchema: Schema<string, string>, _convertedChildren: Array<Node_3>, context: Partial<{
        DefinitionExtension: DefinitionExtensionContext;
    }>): Array<Node_3>;
}

/**
 * @public
 */
export declare interface DefinitionExtensionContext {
    definitions: Record<string, {
        title: string | null | undefined;
        url: string;
    }>;
}

/**
 * @public
 */
export declare class ExtendedAutolinkExtension extends Extension {
    unifiedInitializationHook(processor: Processor<Node_2, Node_2, Node_2, Node_2, string>): Processor<Node_2, Node_2, Node_2, Node_2, string>;
}

/**
 * @public
 */
export declare class GFMExtension extends Extension {
    dependencies(): Array<Extension>;
}

/**
 * @public
 */
export declare class HeadingExtension extends NodeExtension<Heading> {
    private static headingLevelCommandBuilder;
    private static isAtStart;
    dependencies(): Array<Extension>;
    proseMirrorInputRules(proseMirrorSchema: Schema<string, string>): Array<InputRule>;
    proseMirrorKeymap(proseMirrorSchema: Schema<string, string>): Record<string, Command>;
    proseMirrorNodeName(): string;
    proseMirrorNodeSpec(): NodeSpec;
    proseMirrorNodeToUnistNodes(node: Node_3, convertedChildren: Array<PhrasingContent>): Array<Heading>;
    unistNodeName(): "heading";
    unistNodeToProseMirrorNodes(node: Heading, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
}

/**
 * @public
 */
export declare class HorizontalRuleExtension extends NodeExtension<ThematicBreak> {
    proseMirrorInputRules(proseMirrorSchema: Schema<string, string>): Array<InputRule>;
    proseMirrorKeymap(proseMirrorSchema: Schema<string, string>): Record<string, Command>;
    proseMirrorNodeName(): string;
    proseMirrorNodeSpec(): NodeSpec;
    proseMirrorNodeToUnistNodes(): Array<ThematicBreak>;
    unistNodeName(): "thematicBreak";
    unistNodeToProseMirrorNodes(_node: ThematicBreak, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
}

/**
 * @public
 */
export declare class ImageExtension extends NodeExtension<Image_2> {
    dependencies(): Array<Extension>;
    proseMirrorNodeName(): string;
    proseMirrorNodeSpec(): NodeSpec;
    proseMirrorNodeToUnistNodes(node: Node_3): Array<Image_2>;
    unistNodeName(): "image";
    unistNodeToProseMirrorNodes(node: Image_2, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
}

/**
 * @public
 */
export declare class ImageReferenceExtension extends NodeExtension<ImageReference> {
    dependencies(): Array<Extension>;
    postUnistToProseMirrorHook(context: Partial<{
        DefinitionExtension: DefinitionExtensionContext;
        ImageReferenceExtension: ImageReferenceExtensionContext;
    }>): void;
    proseMirrorNodeName(): null;
    proseMirrorNodeSpec(): null;
    proseMirrorNodeToUnistNodes(): Array<ImageReference>;
    unistNodeName(): "imageReference";
    unistNodeToProseMirrorNodes(node: ImageReference, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>, context: Partial<{
        ImageReferenceExtension: ImageReferenceExtensionContext;
    }>): Array<Node_3>;
}

/**
 * @public
 */
export declare interface ImageReferenceExtensionContext {
    proseMirrorNodes: Record<string, Node_3>;
}

/**
 * @public
 */
export declare class InlineCodeExtension extends MarkExtension<InlineCode> {
    processConvertedUnistNode(convertedNode: Text_2): InlineCode;
    proseMirrorInputRules(proseMirrorSchema: Schema<string, string>): Array<InputRule>;
    proseMirrorKeymap(proseMirrorSchema: Schema<string, string>): Record<string, Command>;
    proseMirrorMarkName(): string;
    proseMirrorMarkSpec(): MarkSpec;
    unistNodeName(): "inlineCode";
    unistNodeToProseMirrorNodes(node: InlineCode, proseMirrorSchema: Schema<string, string>): Array<Node_3>;
}

/**
 * @public
 */
export declare class ItalicExtension extends MarkExtension<Emphasis> {
    processConvertedUnistNode(convertedNode: Strong | Text_2): Emphasis;
    proseMirrorInputRules(proseMirrorSchema: Schema<string, string>): Array<InputRule>;
    proseMirrorKeymap(proseMirrorSchema: Schema<string, string>): Record<string, Command>;
    proseMirrorMarkName(): string;
    proseMirrorMarkSpec(): MarkSpec;
    unistNodeName(): "emphasis";
    unistNodeToProseMirrorNodes(_node: Emphasis, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
}

/**
 * @public
 */
export declare class LinkExtension extends MarkExtension<Link> {
    processConvertedUnistNode(convertedNode: Text_2, originalMark: Mark): Link;
    proseMirrorMarkName(): string;
    proseMirrorMarkSpec(): MarkSpec;
    unistNodeName(): "link";
    unistNodeToProseMirrorNodes(node: Link, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
}

/**
 * @public
 */
export declare class LinkReferenceExtension extends MarkExtension<LinkReference> {
    dependencies(): Array<Extension>;
    postUnistToProseMirrorHook(context: Partial<{
        DefinitionExtension: DefinitionExtensionContext;
        LinkReferenceExtension: LinkReferenceExtensionContext;
    }>): void;
    processConvertedUnistNode(convertedNode: LinkReference): LinkReference;
    proseMirrorMarkName(): null;
    proseMirrorMarkSpec(): null;
    unistNodeName(): "linkReference";
    unistNodeToProseMirrorNodes(node: LinkReference, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>, context: Partial<{
        LinkReferenceExtension: LinkReferenceExtensionContext;
    }>): Array<Node_3>;
}

/**
 * @public
 */
export declare interface LinkReferenceExtensionContext {
    marks: Record<string, Mark>;
}

/**
 * @public
 */
export declare class ListItemExtension extends NodeExtension<ListItem> {
    proseMirrorKeymap(proseMirrorSchema: Schema<string, string>): Record<string, Command>;
    proseMirrorNodeName(): string;
    proseMirrorNodeSpec(): NodeSpec;
    proseMirrorNodeToUnistNodes(_node: Node_3, convertedChildren: Array<BlockContent | DefinitionContent>): Array<ListItem>;
    unistNodeName(): "listItem";
    unistNodeToProseMirrorNodes(_node: ListItem, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
    unistToProseMirrorTest(node: Node_2): boolean;
}

/**
 * @public
 */
export declare class MarkdownExtension extends Extension {
    dependencies(): Array<Extension>;
    unifiedInitializationHook(processor: Processor<Node_2, Node_2, Node_2, Node_2, string>): Processor<Node_2, Node_2, Node_2, Node_2, string>;
}

/**
 * @public
 */
export declare class OrderedListExtension extends NodeExtension<List> {
    dependencies(): Array<Extension>;
    proseMirrorInputRules(proseMirrorSchema: Schema<string, string>): Array<InputRule>;
    proseMirrorKeymap(proseMirrorSchema: Schema<string, string>): Record<string, Command>;
    proseMirrorNodeName(): string;
    proseMirrorNodeSpec(): NodeSpec;
    proseMirrorNodeToUnistNodes(node: Node_3, convertedChildren: Array<ListContent>): Array<List>;
    unistNodeName(): "list";
    unistNodeToProseMirrorNodes(node: List, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
    unistToProseMirrorTest(node: Node_2): boolean;
}

/**
 * @public
 */
export declare class ParagraphExtension extends NodeExtension<Paragraph> {
    proseMirrorNodeName(): string;
    proseMirrorNodeSpec(): NodeSpec;
    proseMirrorNodeToUnistNodes(_node: Node_3, convertedChildren: Array<PhrasingContent>): Array<Paragraph>;
    unistNodeName(): "paragraph";
    unistNodeToProseMirrorNodes(_node: Paragraph, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
}

/**
 * @public
 */
export declare class RootExtension extends NodeExtension<Root> {
    proseMirrorNodeName(): string;
    proseMirrorNodeSpec(): NodeSpec;
    proseMirrorNodeToUnistNodes(_node: Node_3, convertedChildren: Array<RootContent>): Array<Root>;
    unistNodeName(): "root";
    unistNodeToProseMirrorNodes(_node: Root, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
}

/**
 * @public
 */
export declare class StrikethroughExtension extends MarkExtension<Delete> {
    processConvertedUnistNode(convertedNode: Emphasis | Text_2): Delete;
    proseMirrorInputRules(proseMirrorSchema: Schema<string, string>): Array<InputRule>;
    proseMirrorMarkName(): string;
    proseMirrorMarkSpec(): MarkSpec;
    unifiedInitializationHook(processor: Processor<Node_2, Node_2, Node_2, Node_2, string>): Processor<Node_2, Node_2, Node_2, Node_2, string>;
    unistNodeName(): "delete";
    unistNodeToProseMirrorNodes(_node: Delete, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
}

/**
 * @public
 */
export declare class TaskListItemExtension extends NodeExtension<ListItem> {
    private static isAtStart;
    proseMirrorInputRules(proseMirrorSchema: Schema<string, string>): Array<InputRule>;
    proseMirrorKeymap(proseMirrorSchema: Schema<string, string>): Record<string, Command>;
    proseMirrorNodeName(): string;
    proseMirrorNodeSpec(): NodeSpec;
    proseMirrorNodeToUnistNodes(node: Node_3, convertedChildren: Array<BlockContent | DefinitionContent>): Array<ListItem>;
    proseMirrorNodeView(): NodeViewConstructor | null;
    unifiedInitializationHook(processor: Processor<Node_2, Node_2, Node_2, Node_2, string>): Processor<Node_2, Node_2, Node_2, Node_2, string>;
    unistNodeName(): "listItem";
    unistNodeToProseMirrorNodes(node: ListItem, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
    unistToProseMirrorTest(node: Node_2): boolean;
}

/**
 * @public
 */
export declare class TextExtension extends NodeExtension<Text_2> {
    proseMirrorNodeName(): string;
    proseMirrorNodeSpec(): NodeSpec;
    proseMirrorNodeToUnistNodes(node: Node_3): Array<Text_2>;
    unistNodeName(): "text";
    unistNodeToProseMirrorNodes(node: Text_2, proseMirrorSchema: Schema<string, string>): Array<Node_3>;
}

/**
 * @public
 */
export declare class UnorderedListExtension extends NodeExtension<List> {
    dependencies(): Array<Extension>;
    proseMirrorInputRules(proseMirrorSchema: Schema<string, string>): Array<InputRule>;
    proseMirrorKeymap(proseMirrorSchema: Schema<string, string>): Record<string, Command>;
    proseMirrorNodeName(): string;
    proseMirrorNodeSpec(): NodeSpec;
    proseMirrorNodeToUnistNodes(node: Node_3, convertedChildren: Array<ListContent>): Array<List>;
    unistNodeName(): "list";
    unistNodeToProseMirrorNodes(node: List, proseMirrorSchema: Schema<string, string>, convertedChildren: Array<Node_3>): Array<Node_3>;
    unistToProseMirrorTest(node: Node_2): boolean;
}

export { }