@remirror/pm/trailing-node/dist/_tsup-dts-rollup.d.ts

A bundled library containing all the core prosemirror libraries required for using remirror

import { __Area } from 'prosemirror-tables';
import { __clipCells } from 'prosemirror-tables';
import { __insertCells } from 'prosemirror-tables';
import { __pastedCells } from 'prosemirror-tables';
import { addColSpan } from 'prosemirror-tables';
import { addColumn } from 'prosemirror-tables';
import { addColumnAfter } from 'prosemirror-tables';
import { addColumnBefore } from 'prosemirror-tables';
import { AddIgnoredProps } from 'prosemirror-suggest';
import { addListNodes } from 'prosemirror-schema-list';
import { AddMarkStep } from 'prosemirror-transform';
import { AddNodeMarkStep } from 'prosemirror-transform';
import { addRow } from 'prosemirror-tables';
import { addRowAfter } from 'prosemirror-tables';
import { addRowBefore } from 'prosemirror-tables';
import { addSuggester } from 'prosemirror-suggest';
import { AllSelection } from 'prosemirror-state';
import { AttributeSpec } from 'prosemirror-model';
import { Attrs } from 'prosemirror-model';
import { AttrStep } from 'prosemirror-transform';
import { autoJoin } from 'prosemirror-commands';
import { baseKeymap } from 'prosemirror-commands';
import { bulletList } from 'prosemirror-schema-list';
import { canJoin } from 'prosemirror-transform';
import { canSplit } from 'prosemirror-transform';
import { cellAround } from 'prosemirror-tables';
import { CellAttributes } from 'prosemirror-tables';
import { CellBookmark } from 'prosemirror-tables';
import { cellNear } from 'prosemirror-tables';
import { CellSelection } from 'prosemirror-tables';
import { CellSelectionJSON } from 'prosemirror-tables';
import { ChangeReason } from 'prosemirror-suggest';
import { CheckNextValidSelection } from 'prosemirror-suggest';
import { closeDoubleQuote } from 'prosemirror-inputrules';
import { closeHistory } from 'prosemirror-history';
import { closeSingleQuote } from 'prosemirror-inputrules';
import { colCount } from 'prosemirror-tables';
import { collab } from 'prosemirror-collab';
import { columnIsHeader } from 'prosemirror-tables';
import { columnResizing } from 'prosemirror-tables';
import { ColumnResizingOptions } from 'prosemirror-tables';
import { columnResizingPluginKey } from 'prosemirror-tables';
import { ColWidths } from 'prosemirror-tables';
import { Command } from 'prosemirror-state';
import { CompareMatchProps } from 'prosemirror-suggest';
import { ContentMatch } from 'prosemirror-model';
import { createParagraphNear } from 'prosemirror-commands';
import { createRegexFromSuggester } from 'prosemirror-suggest';
import { Decoration } from 'prosemirror-view';
import { DecorationAttrs } from 'prosemirror-view';
import { DecorationSet } from 'prosemirror-view';
import { DecorationSource } from 'prosemirror-view';
import { DEFAULT_SUGGESTER } from 'prosemirror-suggest';
import { deleteCellSelection } from 'prosemirror-tables';
import { deleteColumn } from 'prosemirror-tables';
import { deleteRow } from 'prosemirror-tables';
import { deleteSelection } from 'prosemirror-commands';
import { deleteTable } from 'prosemirror-tables';
import { DirectEditorProps } from 'prosemirror-view';
import { Direction } from 'prosemirror-tables';
import { DocAttrStep } from 'prosemirror-transform';
import { DocChangedProps } from 'prosemirror-suggest';
import { DOMEventMap } from 'prosemirror-view';
import { DOMOutputSpec } from 'prosemirror-model';
import { DOMParser as DOMParser_2 } from 'prosemirror-model';
import { DOMSerializer } from 'prosemirror-model';
import { Dragging } from 'prosemirror-tables';
import { dropCursor } from 'prosemirror-dropcursor';
import { dropPoint } from 'prosemirror-transform';
import { EditorProps } from 'prosemirror-view';
import { EditorSchema as EditorSchema_alias_1 } from 'prosemirror-suggest';
import { EditorState } from 'prosemirror-state';
import { EditorState as EditorState_alias_2 } from 'prosemirror-suggest';
import { EditorStateConfig } from 'prosemirror-state';
import { EditorStateProps } from 'prosemirror-suggest';
import { EditorView } from 'prosemirror-view';
import { EditorView as EditorView_alias_1 } from 'prosemirror-suggest';
import { EditorViewProps } from 'prosemirror-suggest';
import { ellipsis } from 'prosemirror-inputrules';
import { emDash } from 'prosemirror-inputrules';
import { exitCode } from 'prosemirror-commands';
import { ExitReason } from 'prosemirror-suggest';
import { FileDropHandlerProps } from 'prosemirror-paste-rules';
import { FileHandlerProps } from 'prosemirror-paste-rules';
import { FilePasteHandlerProps } from 'prosemirror-paste-rules';
import { FilePasteRule } from 'prosemirror-paste-rules';
import { findCell } from 'prosemirror-tables';
import { findFromSuggesters } from 'prosemirror-suggest';
import { findWrapping } from 'prosemirror-transform';
import { fixTables } from 'prosemirror-tables';
import { fixTablesKey } from 'prosemirror-tables';
import { Fragment } from 'prosemirror-model';
import { GapCursor } from 'prosemirror-gapcursor';
import { gapCursor } from 'prosemirror-gapcursor';
import { GenericParseRule } from 'prosemirror-model';
import { GetCellTypeOptions } from 'prosemirror-tables';
import { getFromDOM } from 'prosemirror-tables';
import { getSuggesterWithDefaults } from 'prosemirror-suggest';
import { getSuggestPluginState } from 'prosemirror-suggest';
import { getVersion } from 'prosemirror-collab';
import { goToNextCell } from 'prosemirror-tables';
import { handlePaste } from 'prosemirror-tables';
import { history as history_2 } from 'prosemirror-history';
import { IGNORE_SUGGEST_META_KEY } from 'prosemirror-suggest';
import { ignoreUpdateForSuggest } from 'prosemirror-suggest';
import { InputRule } from 'prosemirror-inputrules';
import { inputRules } from 'prosemirror-inputrules';
import { inSameTable } from 'prosemirror-tables';
import { insertPoint } from 'prosemirror-transform';
import { isChangeReason } from 'prosemirror-suggest';
import { isExitReason } from 'prosemirror-suggest';
import { isInCode } from 'prosemirror-paste-rules';
import { IsInCodeOptions } from 'prosemirror-paste-rules';
import { isInTable } from 'prosemirror-tables';
import { isInvalidSplitReason } from 'prosemirror-suggest';
import { isJumpReason } from 'prosemirror-suggest';
import { isRemovedReason } from 'prosemirror-suggest';
import { isSelectionChangeReason } from 'prosemirror-suggest';
import { isSelectionExitReason } from 'prosemirror-suggest';
import { isSplitReason } from 'prosemirror-suggest';
import { isValidMatch } from 'prosemirror-suggest';
import { joinBackward } from 'prosemirror-commands';
import { joinDown } from 'prosemirror-commands';
import { joinForward } from 'prosemirror-commands';
import { joinPoint } from 'prosemirror-transform';
import { joinTextblockBackward } from 'prosemirror-commands';
import { joinTextblockForward } from 'prosemirror-commands';
import { joinUp } from 'prosemirror-commands';
import { keydownHandler } from 'prosemirror-keymap';
import { keymap } from 'prosemirror-keymap';
import { lift } from 'prosemirror-commands';
import { liftEmptyBlock } from 'prosemirror-commands';
import { liftListItem } from 'prosemirror-schema-list';
import { liftTarget } from 'prosemirror-transform';
import { listItem } from 'prosemirror-schema-list';
import { macBaseKeymap } from 'prosemirror-commands';
import { MakeOptional } from 'prosemirror-suggest';
import { Mappable } from 'prosemirror-transform';
import { Mapping } from 'prosemirror-transform';
import { MapResult } from 'prosemirror-transform';
import { Mark } from 'prosemirror-model';
import { markActiveInRange } from 'prosemirror-suggest';
import { MarkPasteRule } from 'prosemirror-paste-rules';
import { MarkSpec } from 'prosemirror-model';
import { MarkType } from 'prosemirror-model';
import { MarkView } from 'prosemirror-view';
import { MarkViewConstructor } from 'prosemirror-view';
import { MatchValue } from 'prosemirror-suggest';
import { mergeCells } from 'prosemirror-tables';
import { moveCellForward } from 'prosemirror-tables';
import { MutableAttrs } from 'prosemirror-tables';
import { newlineInCode } from 'prosemirror-commands';
import { nextCell } from 'prosemirror-tables';
import { Node as Node_2 } from 'prosemirror-model';
import { NodePasteRule } from 'prosemirror-paste-rules';
import { NodeRange } from 'prosemirror-model';
import { NodeSelection } from 'prosemirror-state';
import { NodeSpec } from 'prosemirror-model';
import { NodeType } from 'prosemirror-model';
import { NodeView } from 'prosemirror-view';
import { NodeViewConstructor } from 'prosemirror-view';
import { openDoubleQuote } from 'prosemirror-inputrules';
import { openSingleQuote } from 'prosemirror-inputrules';
import { orderedList } from 'prosemirror-schema-list';
import { ParseOptions } from 'prosemirror-model';
import { ParseRule } from 'prosemirror-model';
import { PasteRule } from 'prosemirror-paste-rules';
import { pasteRules } from 'prosemirror-paste-rules';
import { pcBaseKeymap } from 'prosemirror-commands';
import { Plugin as Plugin_2 } from 'prosemirror-state';
import { PluginKey } from 'prosemirror-state';
import { PluginSpec } from 'prosemirror-state';
import { PluginView } from 'prosemirror-state';
import { chainCommands as pmChainCommands } from 'prosemirror-commands';
import { pointsAtCell } from 'prosemirror-tables';
import { positionHasMarks } from 'prosemirror-suggest';
import { Problem } from 'prosemirror-tables';
import { ProsemirrorNode as ProsemirrorNode_alias_1 } from 'prosemirror-suggest';
import { rangeHasMarks } from 'prosemirror-suggest';
import { RangeWithCursor } from 'prosemirror-suggest';
import { ReasonMatchProps } from 'prosemirror-suggest';
import { ReasonProps } from 'prosemirror-suggest';
import { receiveTransaction } from 'prosemirror-collab';
import { Rect } from 'prosemirror-tables';
import { redo } from 'prosemirror-history';
import { redoDepth } from 'prosemirror-history';
import { redoNoScroll } from 'prosemirror-history';
import { removeColSpan } from 'prosemirror-tables';
import { removeColumn } from 'prosemirror-tables';
import { RemoveIgnoredProps } from 'prosemirror-suggest';
import { RemoveMarkStep } from 'prosemirror-transform';
import { RemoveNodeMarkStep } from 'prosemirror-transform';
import { removeRow } from 'prosemirror-tables';
import { removeSuggester } from 'prosemirror-suggest';
import { ReplaceAroundStep } from 'prosemirror-transform';
import { ReplaceError } from 'prosemirror-model';
import { ReplaceStep } from 'prosemirror-transform';
import { replaceStep } from 'prosemirror-transform';
import { ResizeState } from 'prosemirror-tables';
import { ResolvedPos } from 'prosemirror-model';
import { ResolvedPos as ResolvedPos_alias_2 } from 'prosemirror-suggest';
import { ResolvedPosProps } from 'prosemirror-suggest';
import { ResolvedRangeWithCursor } from 'prosemirror-suggest';
import { rowIsHeader } from 'prosemirror-tables';
import { Schema } from 'prosemirror-model';
import { SchemaSpec } from 'prosemirror-model';
import { selectAll } from 'prosemirror-commands';
import { selectedRect } from 'prosemirror-tables';
import { Selection as Selection_2 } from 'prosemirror-state';
import { SelectionBookmark } from 'prosemirror-state';
import { selectionCell } from 'prosemirror-tables';
import { selectionOutsideMatch } from 'prosemirror-suggest';
import { SelectionProps } from 'prosemirror-suggest';
import { SelectionRange } from 'prosemirror-state';
import { selectNodeBackward } from 'prosemirror-commands';
import { selectNodeForward } from 'prosemirror-commands';
import { selectParentNode } from 'prosemirror-commands';
import { selectTextblockEnd } from 'prosemirror-commands';
import { selectTextblockStart } from 'prosemirror-commands';
import { sendableSteps } from 'prosemirror-collab';
import { setBlockType } from 'prosemirror-commands';
import { setCellAttr } from 'prosemirror-tables';
import { setDOMAttr } from 'prosemirror-tables';
import { ShouldDisableDecorations } from 'prosemirror-suggest';
import { sinkListItem } from 'prosemirror-schema-list';
import { Slice } from 'prosemirror-model';
import { smartQuotes } from 'prosemirror-inputrules';
import { splitBlock } from 'prosemirror-commands';
import { splitBlockAs } from 'prosemirror-commands';
import { splitBlockKeepMarks } from 'prosemirror-commands';
import { splitCell } from 'prosemirror-tables';
import { splitCellWithType } from 'prosemirror-tables';
import { splitListItem } from 'prosemirror-schema-list';
import { splitListItemKeepMarks } from 'prosemirror-schema-list';
import { StateField } from 'prosemirror-state';
import { Step } from 'prosemirror-transform';
import { StepMap } from 'prosemirror-transform';
import { StepResult } from 'prosemirror-transform';
import { StyleParseRule } from 'prosemirror-model';
import { suggest } from 'prosemirror-suggest';
import { SuggestChangeHandler } from 'prosemirror-suggest';
import { SuggestChangeHandlerProps } from 'prosemirror-suggest';
import { Suggester } from 'prosemirror-suggest';
import { SuggesterProps } from 'prosemirror-suggest';
import { SuggestIgnoreProps } from 'prosemirror-suggest';
import { SuggestMarkProps } from 'prosemirror-suggest';
import { SuggestMatch } from 'prosemirror-suggest';
import { SuggestMatchWithReason } from 'prosemirror-suggest';
import { SuggestReasonMap } from 'prosemirror-suggest';
import { SuggestState } from 'prosemirror-suggest';
import { SuggestStateMatchProps } from 'prosemirror-suggest';
import { tableEditing } from 'prosemirror-tables';
import { tableEditingKey } from 'prosemirror-tables';
import { TableEditingOptions } from 'prosemirror-tables';
import { TableMap } from 'prosemirror-tables';
import { TableNodes } from 'prosemirror-tables';
import { tableNodes } from 'prosemirror-tables';
import { TableNodesOptions } from 'prosemirror-tables';
import { tableNodeTypes } from 'prosemirror-tables';
import { TableRect } from 'prosemirror-tables';
import { TableRole } from 'prosemirror-tables';
import { TableView } from 'prosemirror-tables';
import { TagParseRule } from 'prosemirror-model';
import { textblockTypeInputRule } from 'prosemirror-inputrules';
import { TextPasteRule } from 'prosemirror-paste-rules';
import { TextProps } from 'prosemirror-suggest';
import { TextSelection } from 'prosemirror-state';
import { toggleHeader } from 'prosemirror-tables';
import { toggleHeaderCell } from 'prosemirror-tables';
import { toggleHeaderColumn } from 'prosemirror-tables';
import { toggleHeaderRow } from 'prosemirror-tables';
import { ToggleHeaderType } from 'prosemirror-tables';
import { toggleMark } from 'prosemirror-commands';
import { trailingNode } from 'prosemirror-trailing-node';
import { TrailingNodePluginOptions } from 'prosemirror-trailing-node';
import { Transaction } from 'prosemirror-state';
import { Transaction as Transaction_alias_2 } from 'prosemirror-suggest';
import { TransactionProps } from 'prosemirror-suggest';
import { Transform } from 'prosemirror-transform';
import { undo } from 'prosemirror-history';
import { undoDepth } from 'prosemirror-history';
import { undoInputRule } from 'prosemirror-inputrules';
import { undoNoScroll } from 'prosemirror-history';
import { updateColumnsOnResize } from 'prosemirror-tables';
import { ViewMutationRecord } from 'prosemirror-view';
import { wrapIn } from 'prosemirror-commands';
import { wrapInList } from 'prosemirror-schema-list';
import { wrappingInputRule } from 'prosemirror-inputrules';
import { wrapRangeInList } from 'prosemirror-schema-list';

export { __Area }

export { __clipCells }

export { __insertCells }

export { __pastedCells }

export { addColSpan }

export { addColumn }

export { addColumnAfter }

export { addColumnBefore }

export { AddIgnoredProps }

export { addListNodes }

export { AddMarkStep }

export { AddNodeMarkStep }

export { addRow }

export { addRowAfter }

export { addRowBefore }

export { addSuggester }

export { AllSelection }

export { AttributeSpec }

export { Attrs }

export { AttrStep }

export { autoJoin }

export { baseKeymap }

declare type Brand<Type, B> = Type & Branding<B>;

declare const _brand: unique symbol;

declare interface Branding<Type> {
    readonly [_brand]: Type;
}

export { bulletList }

export { canJoin }

export { canSplit }

export { cellAround }

export { CellAttributes }

export { CellBookmark }

export { cellNear }

export { CellSelection }

export { CellSelectionJSON }

/**
 * Creates a fake state that can be used on ProseMirror library commands to make
 * them chainable. The provided Transaction `tr` can be a shared one.
 *
 * @param tr - the chainable transaction that should be amended.
 * @param state - the state of the editor (available via `view.state`).
 *
 * This should not be used other than for passing to `prosemirror-*` library
 * commands.
 */
declare function chainableEditorState(tr: Transaction, state: EditorState): EditorState;
export { chainableEditorState }
export { chainableEditorState as chainableEditorState_alias_1 }

/**
 * Similar to the chainCommands from the `prosemirror-commands` library. Allows
 * multiple commands to be chained together and runs until one of them returns
 * true.
 */
declare function chainCommands<Extra extends object = object>(...commands: Array<CommandFunction<Extra>>): CommandFunction<Extra>;
export { chainCommands }
export { chainCommands as chainCommands_alias_1 }

export { ChangeReason }

export { CheckNextValidSelection }

export { closeDoubleQuote }

export { closeHistory }

export { closeSingleQuote }

export { colCount }

export { collab }

export { columnIsHeader }

export { columnResizing }

export { ColumnResizingOptions }

export { columnResizingPluginKey }

export { ColWidths }

export { Command }

/**
 * A command method for running commands in your editor.
 *
 * @typeParam Schema - the underlying editor schema.
 * @typeParam ExtraProps - extra parameters to add to the command function.
 *
 * @remarks
 *
 * This groups all the prosemirror command arguments into a single parameter.
 *
 * tldr; When `dispatch=undefined` make sure the command function is **idempotent**.
 *
 * One thing to be aware of is that when creating a command function the
 * `tr` should only be updated when the `dispatch` method is available. This is
 * because by convention calling the command function with `dispatch=undefined`
 * is used to check if the function returns `true`, an indicator that it is
 * enabled, or returns `false` to indicate it is not enabled.
 *
 * If the transaction has been updated outside of the `dispatch=true` condition
 * then running the command again will result in multiple transaction updates
 * and unpredictable behavior.
 *
 * @see {@link ProsemirrorCommandFunction}
 */
declare type CommandFunction<ExtraProps extends object = object> = (params: CommandFunctionProps & ExtraProps) => boolean;
export { CommandFunction }
export { CommandFunction as CommandFunction_alias_1 }

/**
 * A parameter builder interface for the remirror `CommandFunction`.
 *
 * @typeParam Schema - the underlying editor schema.
 */
declare interface CommandFunctionProps {
    /**
     * The shared ProseMirror Transaction.
     */
    tr: Transaction;
    /**
     * A snapshot of the ProseMirror editor state.
     */
    state: EditorState;
    /**
     * The dispatch function which causes the command to be performed.
     *
     * @remarks
     *
     * `dispatch` can be `undefined`. When no `dispatch` callback is provided the
     * command should perform a 'dry run', determining whether the command is
     * applicable (`return true`), but not actually performing the action.
     */
    dispatch?: DispatchFunction;
    /**
     * An instance of the ProseMirror editor `view`.
     */
    view?: EditorView;
}
export { CommandFunctionProps }
export { CommandFunctionProps as CommandFunctionProps_alias_1 }

export { CompareMatchProps }

export { ContentMatch }

/**
 * Wraps the default [[ProsemirrorCommandFunction]] and makes it compatible with
 * the default **remirror** [[CommandFunction]] call signature.
 *
 * It extracts all the public APIs of the state object and assigns the
 * chainable transaction to the `state.tr` property to support chaining.
 */
declare function convertCommand<Extra extends object = object>(commandFunction: ProsemirrorCommandFunction): CommandFunction<Extra>;
export { convertCommand }
export { convertCommand as convertCommand_alias_1 }

export { createParagraphNear }

export { createRegexFromSuggester }

export { Decoration }
export { Decoration as Decoration_alias_1 }
export { Decoration as Decoration_alias_2 }

export { DecorationAttrs }

export { DecorationSet }
export { DecorationSet as DecorationSet_alias_1 }
export { DecorationSet as DecorationSet_alias_2 }

export { DecorationSource }

export { DEFAULT_SUGGESTER }

export { deleteCellSelection }

export { deleteColumn }

export { deleteRow }

export { deleteSelection }

export { deleteTable }

export { DirectEditorProps }

export { Direction }

/**
 * Used to apply the Prosemirror transaction to the current {@link EditorState}.
 *
 * @typeParam Schema - the underlying editor schema.
 */
declare type DispatchFunction = (tr: Transaction) => void;
export { DispatchFunction }
export { DispatchFunction as DispatchFunction_alias_1 }

export { DocAttrStep }

export { DocChangedProps }

export { DOMEventMap }

export { DOMOutputSpec }

export { DOMParser_2 as DOMParser }

export { DOMSerializer }

export { Dragging }

export { dropCursor }

export { dropPoint }

export { EditorProps }

export { EditorSchema_alias_1 }

export { EditorState }
export { EditorState as EditorState_alias_1 }
export { EditorState as EditorState_alias_3 }

export { EditorState_alias_2 }

export { EditorStateConfig }

export { EditorStateProps }

export { EditorView }
export { EditorView as EditorView_alias_2 }
export { EditorView as EditorView_alias_3 }

export { EditorView_alias_1 }

export { EditorViewProps }

export { ellipsis }

export { emDash }

export { exitCode }

export { ExitReason }

export { FileDropHandlerProps }

export { FileHandlerProps }

export { FilePasteHandlerProps }

export { FilePasteRule }

export { findCell }

export { findFromSuggesters }

export { findWrapping }

export { fixTables }

export { fixTablesKey }

export { Fragment }
export { Fragment as Fragment_alias_1 }
export { Fragment as Fragment_alias_2 }

export { GapCursor }

export { gapCursor }

export { GenericParseRule }

export { GetCellTypeOptions }

export { getFromDOM }

export { getSuggesterWithDefaults }

export { getSuggestPluginState }

export { getVersion }

export { goToNextCell }

export { handlePaste }

export { history_2 as history }

export { IGNORE_SUGGEST_META_KEY }

export { ignoreUpdateForSuggest }

export { InputRule }
export { InputRule as InputRule_alias_1 }
export { InputRule as InputRule_alias_2 }

export { inputRules }

export { inSameTable }

export { insertPoint }

/**
 * Predicate checking whether the selection is a [[`CellSelection`]].
 *
 * @param value - the value to check
 */
export declare function isCellSelection(value: unknown): value is CellSelection;

export { isChangeReason }

export { isExitReason }

export { isInCode }

export { IsInCodeOptions }

export { isInTable }

export { isInvalidSplitReason }

export { isJumpReason }

export { isRemovedReason }

export { isSelectionChangeReason }

export { isSelectionExitReason }

export { isSplitReason }

export { isValidMatch }

export { joinBackward }

export { joinDown }

export { joinForward }

export { joinPoint }

export { joinTextblockBackward }

export { joinTextblockForward }

export { joinUp }

export { keydownHandler }

export { keymap }

export { lift }

export { liftEmptyBlock }

export { liftListItem }

export { liftTarget }

export { listItem }

export { macBaseKeymap }

export { MakeOptional }

export { Mappable }

export { Mapping }
export { Mapping as Mapping_alias_1 }
export { Mapping as Mapping_alias_2 }

export { MapResult }

export { Mark }
export { Mark as Mark_alias_1 }
export { Mark as Mark_alias_2 }

export { markActiveInRange }

export { MarkPasteRule }

export { MarkSpec }

export { MarkType }
export { MarkType as MarkType_alias_1 }
export { MarkType as MarkType_alias_2 }

export { MarkView }

export { MarkViewConstructor }

export { MatchValue }

export { mergeCells }

export { moveCellForward }

export { MutableAttrs }

export { newlineInCode }

export { nextCell }

export { Node_2 as Node }
export { Node_2 as ProsemirrorNode }
export { Node_2 as ProsemirrorNode_alias_2 }

export { NodePasteRule }

export { NodeRange }

export { NodeSelection }

export { NodeSpec }

export { NodeType }
export { NodeType as NodeType_alias_1 }
export { NodeType as NodeType_alias_2 }

export { NodeView }
export { NodeView as NodeView_alias_1 }
export { NodeView as NodeView_alias_2 }

export { NodeViewConstructor }

/**
 * Marks a command function as non chainable. It will throw an error when
 * chaining is attempted.
 *
 * @remarks
 *
 * ```ts
 * const command = nonChainable(({ state, dispatch }) => {...});
 * ```
 */
declare function nonChainable<Extra extends object = object>(commandFunction: CommandFunction<Extra>): NonChainableCommandFunction<Extra>;
export { nonChainable }
export { nonChainable as nonChainable_alias_1 }

/**
 * Brands a command as non chainable so that it can be excluded from the
 * inferred chainable commands.
 */
declare type NonChainableCommandFunction<Extra extends object = object> = Brand<CommandFunction<Extra>, 'non-chainable'>;
export { NonChainableCommandFunction }
export { NonChainableCommandFunction as NonChainableCommandFunction_alias_1 }

export { openDoubleQuote }

export { openSingleQuote }

export { orderedList }

export { ParseOptions }

export { ParseRule }

export { PasteRule }

export { pasteRules }

export { pcBaseKeymap }

export { Plugin_2 as Plugin }
export { Plugin_2 as ProsemirrorPlugin }
export { Plugin_2 as ProsemirrorPlugin_alias_1 }

export { PluginKey }
export { PluginKey as PluginKey_alias_1 }
export { PluginKey as PluginKey_alias_2 }

export { PluginSpec }

export { PluginView }

export { pmChainCommands }

export { pointsAtCell }

export { positionHasMarks }

export { Problem }

/**
 * This is the type signature for commands within the prosemirror editor.
 *
 * @remarks
 *
 * A command function takes an editor state and optionally a dispatch function
 * that it can use to dispatch a transaction. It should return a boolean that
 * indicates whether it could perform any action.
 *
 * When no dispatch callback is passed, the command should do a 'dry run',
 * determining whether it is applicable, but not actually performing any action.
 *
 * @typeParam Schema - the underlying editor schema.
 */
declare type ProsemirrorCommandFunction = (state: EditorState, dispatch: DispatchFunction | undefined, view: EditorView | undefined) => boolean;
export { ProsemirrorCommandFunction }
export { ProsemirrorCommandFunction as ProsemirrorCommandFunction_alias_1 }

export { ProsemirrorNode_alias_1 }

export { rangeHasMarks }

export { RangeWithCursor }

export { ReasonMatchProps }

export { ReasonProps }

export { receiveTransaction }

export { Rect }

export { redo }

export { redoDepth }

export { redoNoScroll }

export { removeColSpan }

export { removeColumn }

export { RemoveIgnoredProps }

export { RemoveMarkStep }

export { RemoveNodeMarkStep }

export { removeRow }

export { removeSuggester }

export { ReplaceAroundStep }

export { ReplaceError }

export { ReplaceStep }

export { replaceStep }

export { ResizeState }

export { ResolvedPos }
export { ResolvedPos as ResolvedPos_alias_1 }
export { ResolvedPos as ResolvedPos_alias_3 }

export { ResolvedPos_alias_2 }

export { ResolvedPosProps }

export { ResolvedRangeWithCursor }

export { rowIsHeader }

export { Schema as EditorSchema }
export { Schema as EditorSchema_alias_2 }
export { Schema }

export { SchemaSpec }

export { selectAll }

export { selectedRect }

export { Selection_2 as Selection }
export { Selection_2 as Selection_alias_1 }
export { Selection_2 as Selection_alias_2 }

export { SelectionBookmark }

export { selectionCell }

export { selectionOutsideMatch }

export { SelectionProps }

export { SelectionRange }

export { selectNodeBackward }

export { selectNodeForward }

export { selectParentNode }

export { selectTextblockEnd }

export { selectTextblockStart }

export { sendableSteps }

export { setBlockType }

export { setCellAttr }

export { setDOMAttr }

export { ShouldDisableDecorations }

export { sinkListItem }

export { Slice }
export { Slice as Slice_alias_1 }
export { Slice as Slice_alias_2 }

export { smartQuotes }

export { splitBlock }

export { splitBlockAs }

export { splitBlockKeepMarks }

export { splitCell }

export { splitCellWithType }

export { splitListItem }

export { splitListItemKeepMarks }

export { StateField }

export { Step }

export { StepMap }

export { StepResult }

export { StyleParseRule }

export { suggest }

export { SuggestChangeHandler }

export { SuggestChangeHandlerProps }

export { Suggester }

export { SuggesterProps }

export { SuggestIgnoreProps }

export { SuggestMarkProps }

export { SuggestMatch }

export { SuggestMatchWithReason }

export { SuggestReasonMap }

export { SuggestState }

export { SuggestStateMatchProps }

export { tableEditing }

export { tableEditingKey }

export { TableEditingOptions }

export { TableMap }

export { TableNodes }

export { tableNodes }

export { TableNodesOptions }

export { tableNodeTypes }

export { TableRect }

export { TableRole }

export { TableView }

export { TagParseRule }

export { textblockTypeInputRule }

export { TextPasteRule }

export { TextProps }

export { TextSelection }

export { toggleHeader }

export { toggleHeaderCell }

export { toggleHeaderColumn }

export { toggleHeaderRow }

export { ToggleHeaderType }

export { toggleMark }

export { trailingNode }

export { TrailingNodePluginOptions }

export { Transaction }
export { Transaction as Transaction_alias_1 }
export { Transaction as Transaction_alias_3 }

export { Transaction_alias_2 }

export { TransactionProps }

export { Transform }

export { undo }

export { undoDepth }

export { undoInputRule }

export { undoNoScroll }

export { updateColumnsOnResize }

export { ViewMutationRecord }

export { wrapIn }

export { wrapInList }

export { wrappingInputRule }

export { wrapRangeInList }

export { }