slate-vue3 0.0.1

package/dist/slate-vue3.d.ts

@@ -0,0 +1,2825 @@
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComputedRef } from 'vue';
+import { CSSProperties } from 'vue';
+import { DefineComponent } from 'vue';
+import { HTMLAttributes } from 'vue';
+import { JSX } from 'vue/jsx-runtime';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+import { RendererElement } from 'vue';
+import { RendererNode } from 'vue';
+import { VNode } from 'vue';
+import { VNodeRef } from 'vue';
+
+export declare const above: EditorInterface['above'];
+
+declare type Action = {
+    at?: Point | Range_2;
+    run: () => void;
+};
+
+export declare const addMark: EditorInterface['addMark'];
+
+export declare const after: EditorInterface['after'];
+
+/**
+ * The `Ancestor` union type represents nodes that are ancestors in the tree.
+ * It is returned as a convenience in certain cases to narrow a value further
+ * than the more generic `Node` union.
+ */
+export declare type Ancestor = Editor | Element_2;
+
+export declare const apply: WithEditorFirstArg<Editor['apply']>;
+
+export declare function applyStringDiff(text: string, ...diffs: StringDiff[]): string;
+
+/**
+ * The `Editor` interface stores all the state of a Slate editor. It is extended
+ * by plugins that wish to add their own helpers and implement new behaviors.
+ */
+export declare interface BaseEditor {
+    children: Descendant[];
+    selection: Selection_2;
+    operations: Operation[];
+    marks: EditorMarks | null;
+    apply: (operation: Operation) => void;
+    getDirtyPaths: (operation: Operation) => Path[];
+    getFragment: () => Descendant[];
+    isElementReadOnly: (element: Element_2) => boolean;
+    isSelectable: (element: Element_2) => boolean;
+    markableVoid: (element: Element_2) => boolean;
+    normalizeNode: (entry: NodeEntry, options?: {
+        operation?: Operation;
+    }) => void;
+    onChange: (options?: {
+        operation?: Operation;
+    }) => void;
+    shouldNormalize: ({ iteration, dirtyPaths, operation, }: {
+        iteration: number;
+        initialDirtyPathsLength: number;
+        dirtyPaths: Path[];
+        operation?: Operation;
+    }) => boolean;
+    addMark: OmitFirstArg<typeof Editor.addMark>;
+    collapse: OmitFirstArg<typeof Transforms.collapse>;
+    delete: OmitFirstArg<typeof Transforms.delete>;
+    deleteBackward: (unit: TextUnit) => void;
+    deleteForward: (unit: TextUnit) => void;
+    deleteFragment: OmitFirstArg<typeof Editor.deleteFragment>;
+    deselect: OmitFirstArg<typeof Transforms.deselect>;
+    insertBreak: OmitFirstArg<typeof Editor.insertBreak>;
+    insertFragment: OmitFirstArg<typeof Transforms.insertFragment>;
+    insertNode: OmitFirstArg<typeof Editor.insertNode>;
+    insertNodes: OmitFirstArg<typeof Transforms.insertNodes>;
+    insertSoftBreak: OmitFirstArg<typeof Editor.insertSoftBreak>;
+    insertText: OmitFirstArg<typeof Transforms.insertText>;
+    liftNodes: OmitFirstArg<typeof Transforms.liftNodes>;
+    mergeNodes: OmitFirstArg<typeof Transforms.mergeNodes>;
+    move: OmitFirstArg<typeof Transforms.move>;
+    moveNodes: OmitFirstArg<typeof Transforms.moveNodes>;
+    normalize: OmitFirstArg<typeof Editor.normalize>;
+    removeMark: OmitFirstArg<typeof Editor.removeMark>;
+    removeNodes: OmitFirstArg<typeof Transforms.removeNodes>;
+    select: OmitFirstArg<typeof Transforms.select>;
+    setNodes: <T extends Node_2>(props: Partial<T>, options?: {
+        at?: Location_2;
+        match?: NodeMatch<T>;
+        mode?: MaximizeMode;
+        hanging?: boolean;
+        split?: boolean;
+        voids?: boolean;
+        compare?: PropsCompare;
+        merge?: PropsMerge;
+    }) => void;
+    setNormalizing: OmitFirstArg<typeof Editor.setNormalizing>;
+    setPoint: OmitFirstArg<typeof Transforms.setPoint>;
+    setSelection: OmitFirstArg<typeof Transforms.setSelection>;
+    splitNodes: OmitFirstArg<typeof Transforms.splitNodes>;
+    unsetNodes: OmitFirstArg<typeof Transforms.unsetNodes>;
+    unwrapNodes: OmitFirstArg<typeof Transforms.unwrapNodes>;
+    withoutNormalizing: OmitFirstArg<typeof Editor.withoutNormalizing>;
+    wrapNodes: OmitFirstArg<typeof Transforms.wrapNodes>;
+    above: <T extends Ancestor>(options?: EditorAboveOptions<T>) => NodeEntry<T> | undefined;
+    after: OmitFirstArg<typeof Editor.after>;
+    before: OmitFirstArg<typeof Editor.before>;
+    edges: OmitFirstArg<typeof Editor.edges>;
+    elementReadOnly: OmitFirstArg<typeof Editor.elementReadOnly>;
+    end: OmitFirstArg<typeof Editor.end>;
+    first: OmitFirstArg<typeof Editor.first>;
+    fragment: OmitFirstArg<typeof Editor.fragment>;
+    getMarks: OmitFirstArg<typeof Editor.marks>;
+    hasBlocks: OmitFirstArg<typeof Editor.hasBlocks>;
+    hasInlines: OmitFirstArg<typeof Editor.hasInlines>;
+    hasPath: OmitFirstArg<typeof Editor.hasPath>;
+    hasTexts: OmitFirstArg<typeof Editor.hasTexts>;
+    isBlock: OmitFirstArg<typeof Editor.isBlock>;
+    isEdge: OmitFirstArg<typeof Editor.isEdge>;
+    isEmpty: OmitFirstArg<typeof Editor.isEmpty>;
+    isEnd: OmitFirstArg<typeof Editor.isEnd>;
+    isInline: OmitFirstArg<typeof Editor.isInline>;
+    isNormalizing: OmitFirstArg<typeof Editor.isNormalizing>;
+    isStart: OmitFirstArg<typeof Editor.isStart>;
+    isVoid: OmitFirstArg<typeof Editor.isVoid>;
+    last: OmitFirstArg<typeof Editor.last>;
+    leaf: OmitFirstArg<typeof Editor.leaf>;
+    levels: <T extends Node_2>(options?: EditorLevelsOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
+    next: <T extends Descendant>(options?: EditorNextOptions<T>) => NodeEntry<T> | undefined;
+    node: OmitFirstArg<typeof Editor.node>;
+    nodes: <T extends Node_2>(options?: EditorNodesOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
+    parent: OmitFirstArg<typeof Editor.parent>;
+    path: OmitFirstArg<typeof Editor.path>;
+    pathRef: OmitFirstArg<typeof Editor.pathRef>;
+    pathRefs: OmitFirstArg<typeof Editor.pathRefs>;
+    point: OmitFirstArg<typeof Editor.point>;
+    pointRef: OmitFirstArg<typeof Editor.pointRef>;
+    pointRefs: OmitFirstArg<typeof Editor.pointRefs>;
+    positions: OmitFirstArg<typeof Editor.positions>;
+    previous: <T extends Node_2>(options?: EditorPreviousOptions<T>) => NodeEntry<T> | undefined;
+    range: OmitFirstArg<typeof Editor.range>;
+    rangeRef: OmitFirstArg<typeof Editor.rangeRef>;
+    rangeRefs: OmitFirstArg<typeof Editor.rangeRefs>;
+    start: OmitFirstArg<typeof Editor.start>;
+    string: OmitFirstArg<typeof Editor.string>;
+    unhangRange: OmitFirstArg<typeof Editor.unhangRange>;
+    void: OmitFirstArg<typeof Editor.void>;
+    shouldMergeNodesRemovePrevNode: OmitFirstArg<typeof Editor.shouldMergeNodesRemovePrevNode>;
+}
+
+/**
+ * `Element` objects are a type of node in a Slate document that contain other
+ * element nodes or text nodes. They can be either "blocks" or "inlines"
+ * depending on the Slate editor's configuration.
+ */
+export declare interface BaseElement {
+    children: Descendant[];
+}
+
+export declare type BaseInsertNodeOperation = {
+    type: 'insert_node';
+    path: Path;
+    node: Node_2;
+};
+
+export declare type BaseInsertTextOperation = {
+    type: 'insert_text';
+    path: Path;
+    offset: number;
+    text: string;
+};
+
+export declare type BaseMergeNodeOperation = {
+    type: 'merge_node';
+    path: Path;
+    position: number;
+    properties: Partial<Node_2>;
+};
+
+export declare type BaseMoveNodeOperation = {
+    type: 'move_node';
+    path: Path;
+    newPath: Path;
+};
+
+/**
+ * The `Node` union type represents all of the different types of nodes that
+ * occur in a Slate document tree.
+ */
+export declare type BaseNode = Editor | Element_2 | Text_2;
+
+/**
+ * `Operation` objects define the low-level instructions that Slate editors use
+ * to apply changes to their internal state. Representing all changes as
+ * operations is what allows Slate editors to easily implement history,
+ * collaboration, and other features.
+ */
+export declare type BaseOperation = NodeOperation | SelectionOperation | TextOperation;
+
+/**
+ * `Point` objects refer to a specific location in a text node in a Slate
+ * document. Its path refers to the location of the node in the tree, and its
+ * offset refers to the distance into the node's string of text. Points can
+ * only refer to `Text` nodes.
+ */
+export declare interface BasePoint {
+    path: Path;
+    offset: number;
+}
+
+/**
+ * `Range` objects are a set of points that refer to a specific span of a Slate
+ * document. They can define a span inside a single node or a can span across
+ * multiple nodes.
+ */
+export declare interface BaseRange {
+    anchor: Point;
+    focus: Point;
+}
+
+export declare type BaseRemoveNodeOperation = {
+    type: 'remove_node';
+    path: Path;
+    node: Node_2;
+};
+
+export declare type BaseRemoveTextOperation = {
+    type: 'remove_text';
+    path: Path;
+    offset: number;
+    text: string;
+};
+
+export declare type BaseSelection = Range_2 | null;
+
+export declare type BaseSetNodeOperation = {
+    type: 'set_node';
+    path: Path;
+    properties: Partial<Node_2>;
+    newProperties: Partial<Node_2>;
+};
+
+export declare type BaseSetSelectionOperation = {
+    type: 'set_selection';
+    properties: null;
+    newProperties: Range_2;
+} | {
+    type: 'set_selection';
+    properties: Partial<Range_2>;
+    newProperties: Partial<Range_2>;
+} | {
+    type: 'set_selection';
+    properties: Range_2;
+    newProperties: null;
+};
+
+export declare type BaseSplitNodeOperation = {
+    type: 'split_node';
+    path: Path;
+    position: number;
+    properties: Partial<Node_2>;
+};
+
+/**
+ * `Text` objects represent the nodes that contain the actual text content of a
+ * Slate document along with any formatting properties. They are always leaf
+ * nodes in the document tree as they cannot contain any children.
+ */
+export declare interface BaseText {
+    text: string;
+}
+
+export declare const before: EditorInterface['before'];
+
+export declare const CAN_USE_DOM: boolean;
+
+export declare const collapse: SelectionTransforms['collapse'];
+
+/**
+ * Create a new Slate `Editor` object.
+ */
+export declare const createEditor: (children: Descendant[]) => Editor;
+
+export declare interface CustomTypes {
+    [key: string]: unknown;
+}
+
+export declare type DecoratedRange = Range_2 & {
+    /**
+     * Customize how another decoration is merged into a text node. If not specified, `Object.assign` would be used.
+     * It is useful for overlapping decorations with the same key but different values.
+     */
+    merge?: (leaf: Text_2, decoration: object) => void;
+};
+
+export declare const defaultRenderLeaf: ({ attributes, children, }: RenderLeafProps) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>;
+
+export declare const defaultRenderPlaceHolder: ({ attributes, children }: RenderPlaceholderProps) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>;
+
+export declare const deleteBackward: WithEditorFirstArg<Editor['deleteBackward']>;
+
+export declare const deleteForward: WithEditorFirstArg<Editor['deleteForward']>;
+
+export declare const deleteFragment: EditorInterface['deleteFragment'];
+
+export declare const deleteText: TextTransforms['delete'];
+
+/**
+ * The `Descendant` union type represents nodes that are descendants in the
+ * tree. It is returned as a convenience in certain cases to narrow a value
+ * further than the more generic `Node` union.
+ */
+export declare type Descendant = Element_2 | Text_2;
+
+export declare const deselect: SelectionTransforms['deselect'];
+
+/**
+ * A DOM-specific version of the `Editor` interface.
+ */
+export declare interface DOMEditor extends BaseEditor {
+    hasEditableTarget: (editor: DOMEditor, target: EventTarget | null) => target is DOMNode_2;
+    hasRange: (editor: DOMEditor, range: Range_2) => boolean;
+    hasSelectableTarget: (editor: DOMEditor, target: EventTarget | null) => boolean;
+    hasTarget: (editor: DOMEditor, target: EventTarget | null) => target is DOMNode_2;
+    insertData: (data: DataTransfer) => void;
+    insertFragmentData: (data: DataTransfer) => boolean;
+    insertTextData: (data: DataTransfer) => boolean;
+    isTargetInsideNonReadonlyVoid: (editor: DOMEditor, target: EventTarget | null) => boolean;
+    setFragmentData: (data: DataTransfer, originEvent?: 'drag' | 'copy' | 'cut') => void;
+}
+
+export declare const DOMEditor: DOMEditorInterface;
+
+export declare interface DOMEditorInterface {
+    /**
+     * Experimental and android specific: Get pending diffs
+     */
+    androidPendingDiffs: (editor: Editor) => TextDiff[] | undefined;
+    /**
+     * Experimental and android specific: Flush all pending diffs and cancel composition at the next possible time.
+     */
+    androidScheduleFlush: (editor: Editor) => void;
+    /**
+     * Blur the editor.
+     */
+    blur: (editor: DOMEditor) => void;
+    /**
+     * Deselect the editor.
+     */
+    deselect: (editor: DOMEditor) => void;
+    /**
+     * Find the DOM node that implements DocumentOrShadowRoot for the editor.
+     */
+    findDocumentOrShadowRoot: (editor: DOMEditor) => Document | ShadowRoot;
+    /**
+     * Get the target range from a DOM `event`.
+     */
+    findEventRange: (editor: DOMEditor, event: any) => Range_2;
+    /**
+     * Find a key for a Slate node.
+     */
+    findKey: (editor: DOMEditor, node: Node_2) => Key;
+    /**
+     * Find the path of Slate node.
+     */
+    findPath: (editor: DOMEditor, node: Node_2) => Path;
+    /**
+     * Focus the editor.
+     */
+    focus: (editor: DOMEditor, options?: {
+        retries: number;
+    }) => void;
+    /**
+     * Return the host window of the current editor.
+     */
+    getWindow: (editor: DOMEditor) => Window;
+    /**
+     * Check if a DOM node is within the editor.
+     */
+    hasDOMNode: (editor: DOMEditor, target: DOMNode_2, options?: {
+        editable?: boolean;
+    }) => boolean;
+    /**
+     * Check if the target is editable and in the editor.
+     */
+    hasEditableTarget: (editor: DOMEditor, target: EventTarget | null) => target is DOMNode_2;
+    /**
+     *
+     */
+    hasRange: (editor: DOMEditor, range: Range_2) => boolean;
+    /**
+     * Check if the target can be selectable
+     */
+    hasSelectableTarget: (editor: DOMEditor, target: EventTarget | null) => boolean;
+    /**
+     * Check if the target is in the editor.
+     */
+    hasTarget: (editor: DOMEditor, target: EventTarget | null) => target is DOMNode_2;
+    /**
+     * Insert data from a `DataTransfer` into the editor.
+     */
+    insertData: (editor: DOMEditor, data: DataTransfer) => void;
+    /**
+     * Insert fragment data from a `DataTransfer` into the editor.
+     */
+    insertFragmentData: (editor: DOMEditor, data: DataTransfer) => boolean;
+    /**
+     * Insert text data from a `DataTransfer` into the editor.
+     */
+    insertTextData: (editor: DOMEditor, data: DataTransfer) => boolean;
+    /**
+     * Check if the user is currently composing inside the editor.
+     */
+    isComposing: (editor: DOMEditor) => boolean;
+    /**
+     * Check if the editor is focused.
+     */
+    isFocused: (editor: DOMEditor) => boolean;
+    /**
+     * Check if the editor is in read-only mode.
+     */
+    isReadOnly: (editor: DOMEditor) => boolean;
+    /**
+     * Check if the target is inside void and in an non-readonly editor.
+     */
+    isTargetInsideNonReadonlyVoid: (editor: DOMEditor, target: EventTarget | null) => boolean;
+    /**
+     * Sets data from the currently selected fragment on a `DataTransfer`.
+     */
+    setFragmentData: (editor: DOMEditor, data: DataTransfer, originEvent?: 'drag' | 'copy' | 'cut') => void;
+    /**
+     * Find the native DOM element from a Slate node.
+     */
+    toDOMNode: (editor: DOMEditor, node: Node_2) => HTMLElement;
+    /**
+     * Find a native DOM selection point from a Slate point.
+     */
+    toDOMPoint: (editor: DOMEditor, point: Point) => DOMPoint_2;
+    /**
+     * Find a native DOM range from a Slate `range`.
+     *
+     * Notice: the returned range will always be ordinal regardless of the direction of Slate `range` due to DOM API limit.
+     *
+     * there is no way to create a reverse DOM Range using Range.setStart/setEnd
+     * according to https://dom.spec.whatwg.org/#concept-range-bp-set.
+     */
+    toDOMRange: (editor: DOMEditor, range: Range_2) => DOMRange_2;
+    /**
+     * Find a Slate node from a native DOM `element`.
+     */
+    toSlateNode: (editor: DOMEditor, domNode: DOMNode_2) => Node_2;
+    /**
+     * Find a Slate point from a DOM selection's `domNode` and `domOffset`.
+     */
+    toSlatePoint: <T extends boolean>(editor: DOMEditor, domPoint: DOMPoint_2, options: {
+        exactMatch: boolean;
+        suppressThrow: T;
+        /**
+         * The direction to search for Slate leaf nodes if `domPoint` is
+         * non-editable and non-void.
+         */
+        searchDirection?: 'forward' | 'backward';
+    }) => T extends true ? Point | null : Point;
+    /**
+     * Find a Slate range from a DOM range or selection.
+     */
+    toSlateRange: <T extends boolean>(editor: DOMEditor, domRange: DOMRange_2 | DOMStaticRange_2 | DOMSelection_2, options: {
+        exactMatch: boolean;
+        suppressThrow: T;
+    }) => T extends true ? Range_2 | null : Range_2;
+}
+
+export declare type DOMElement = globalThis.Element;
+
+declare type DOMElement_2 = globalThis.Element;
+
+export declare type DOMNode = globalThis.Node;
+
+declare type DOMNode_2 = globalThis.Node;
+
+/**
+ * Types.
+ */
+declare type DOMNode_3 = globalThis.Node;
+
+declare type DOMPoint_2 = [Node, number];
+export { DOMPoint_2 as DOMPoint }
+
+export declare type DOMRange = globalThis.Range;
+
+declare type DOMRange_2 = globalThis.Range;
+
+export declare type DOMSelection = globalThis.Selection;
+
+declare type DOMSelection_2 = globalThis.Selection;
+
+declare type DOMSelection_3 = globalThis.Selection;
+
+export declare type DOMStaticRange = globalThis.StaticRange;
+
+declare type DOMStaticRange_2 = globalThis.StaticRange;
+
+export declare type DOMText = globalThis.Text;
+
+export declare const edges: EditorInterface['edges'];
+
+/**
+ * Editable.
+ */
+export declare const Editable: DefineComponent<    {
+onDOMBeforeInput?: ((event: InputEvent) => void) | undefined;
+role?: string | undefined;
+readOnly: boolean;
+placeholder?: string | undefined;
+style?: CSSProperties | undefined;
+scrollSelectionIntoView: (editor: DOMEditor, domRange: globalThis.Range) => void;
+is: string;
+innerHTML?: string | undefined;
+class?: any;
+accesskey?: string | undefined;
+contenteditable?: ((boolean | "false" | "true") | "inherit" | "plaintext-only") | undefined;
+contextmenu?: string | undefined;
+dir?: string | undefined;
+draggable?: (boolean | "false" | "true") | undefined;
+hidden?: ((boolean | "false" | "true") | "" | "hidden" | "until-found") | undefined;
+id?: string | undefined;
+inert?: (boolean | "false" | "true") | undefined;
+lang?: string | undefined;
+spellcheck?: (boolean | "false" | "true") | undefined;
+tabindex?: (string | number) | undefined;
+title?: string | undefined;
+translate?: "yes" | "no" | undefined;
+radiogroup?: string | undefined;
+about?: string | undefined;
+datatype?: string | undefined;
+inlist?: any;
+prefix?: string | undefined;
+property?: string | undefined;
+resource?: string | undefined;
+typeof?: string | undefined;
+vocab?: string | undefined;
+autocapitalize?: string | undefined;
+autocorrect?: string | undefined;
+autosave?: string | undefined;
+color?: string | undefined;
+itemprop?: string | undefined;
+itemscope?: (boolean | "false" | "true") | undefined;
+itemtype?: string | undefined;
+itemid?: string | undefined;
+itemref?: string | undefined;
+results?: (string | number) | undefined;
+security?: string | undefined;
+unselectable?: "on" | "off" | undefined;
+inputmode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+'aria-activedescendant'?: string | undefined;
+'aria-atomic'?: (boolean | "false" | "true") | undefined;
+'aria-autocomplete'?: "none" | "inline" | "list" | "both" | undefined;
+'aria-busy'?: (boolean | "false" | "true") | undefined;
+'aria-checked'?: ((boolean | "false" | "true") | "mixed") | undefined;
+'aria-colcount'?: (string | number) | undefined;
+'aria-colindex'?: (string | number) | undefined;
+'aria-colspan'?: (string | number) | undefined;
+'aria-controls'?: string | undefined;
+'aria-current'?: ((boolean | "false" | "true") | "page" | "step" | "location" | "date" | "time") | undefined;
+'aria-describedby'?: string | undefined;
+'aria-details'?: string | undefined;
+'aria-disabled'?: (boolean | "false" | "true") | undefined;
+'aria-dropeffect'?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+'aria-errormessage'?: string | undefined;
+'aria-expanded'?: (boolean | "false" | "true") | undefined;
+'aria-flowto'?: string | undefined;
+'aria-grabbed'?: (boolean | "false" | "true") | undefined;
+'aria-haspopup'?: ((boolean | "false" | "true") | "menu" | "listbox" | "tree" | "grid" | "dialog") | undefined;
+'aria-hidden'?: (boolean | "false" | "true") | undefined;
+'aria-invalid'?: ((boolean | "false" | "true") | "grammar" | "spelling") | undefined;
+'aria-keyshortcuts'?: string | undefined;
+'aria-label'?: string | undefined;
+'aria-labelledby'?: string | undefined;
+'aria-level'?: (string | number) | undefined;
+'aria-live'?: "off" | "assertive" | "polite" | undefined;
+'aria-modal'?: (boolean | "false" | "true") | undefined;
+'aria-multiline'?: (boolean | "false" | "true") | undefined;
+'aria-multiselectable'?: (boolean | "false" | "true") | undefined;
+'aria-orientation'?: "horizontal" | "vertical" | undefined;
+'aria-owns'?: string | undefined;
+'aria-placeholder'?: string | undefined;
+'aria-posinset'?: (string | number) | undefined;
+'aria-pressed'?: ((boolean | "false" | "true") | "mixed") | undefined;
+'aria-readonly'?: (boolean | "false" | "true") | undefined;
+'aria-relevant'?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+'aria-required'?: (boolean | "false" | "true") | undefined;
+'aria-roledescription'?: string | undefined;
+'aria-rowcount'?: (string | number) | undefined;
+'aria-rowindex'?: (string | number) | undefined;
+'aria-rowspan'?: (string | number) | undefined;
+'aria-selected'?: (boolean | "false" | "true") | undefined;
+'aria-setsize'?: (string | number) | undefined;
+'aria-sort'?: "none" | "ascending" | "descending" | "other" | undefined;
+'aria-valuemax'?: (string | number) | undefined;
+'aria-valuemin'?: (string | number) | undefined;
+'aria-valuenow'?: (string | number) | undefined;
+'aria-valuetext'?: string | undefined;
+onCopy?: ((payload: ClipboardEvent) => void) | undefined;
+onCut?: ((payload: ClipboardEvent) => void) | undefined;
+onPaste?: ((payload: ClipboardEvent) => void) | undefined;
+onCompositionend?: ((payload: CompositionEvent) => void) | undefined;
+onCompositionstart?: ((payload: CompositionEvent) => void) | undefined;
+onCompositionupdate?: ((payload: CompositionEvent) => void) | undefined;
+onDrag?: ((payload: DragEvent) => void) | undefined;
+onDragend?: ((payload: DragEvent) => void) | undefined;
+onDragenter?: ((payload: DragEvent) => void) | undefined;
+onDragexit?: ((payload: DragEvent) => void) | undefined;
+onDragleave?: ((payload: DragEvent) => void) | undefined;
+onDragover?: ((payload: DragEvent) => void) | undefined;
+onDragstart?: ((payload: DragEvent) => void) | undefined;
+onDrop?: ((payload: DragEvent) => void) | undefined;
+onFocus?: ((payload: FocusEvent) => void) | undefined;
+onFocusin?: ((payload: FocusEvent) => void) | undefined;
+onFocusout?: ((payload: FocusEvent) => void) | undefined;
+onBlur?: ((payload: FocusEvent) => void) | undefined;
+onChange?: ((payload: Event) => void) | undefined;
+onBeforeinput?: ((payload: Event) => void) | undefined;
+onInput?: ((payload: Event) => void) | undefined;
+onReset?: ((payload: Event) => void) | undefined;
+onSubmit?: ((payload: Event) => void) | undefined;
+onInvalid?: ((payload: Event) => void) | undefined;
+onLoad?: ((payload: Event) => void) | undefined;
+onError?: ((payload: Event) => void) | undefined;
+onKeydown?: ((payload: KeyboardEvent) => void) | undefined;
+onKeypress?: ((payload: KeyboardEvent) => void) | undefined;
+onKeyup?: ((payload: KeyboardEvent) => void) | undefined;
+onAuxclick?: ((payload: MouseEvent) => void) | undefined;
+onClick?: ((payload: MouseEvent) => void) | undefined;
+onContextmenu?: ((payload: MouseEvent) => void) | undefined;
+onDblclick?: ((payload: MouseEvent) => void) | undefined;
+onMousedown?: ((payload: MouseEvent) => void) | undefined;
+onMouseenter?: ((payload: MouseEvent) => void) | undefined;
+onMouseleave?: ((payload: MouseEvent) => void) | undefined;
+onMousemove?: ((payload: MouseEvent) => void) | undefined;
+onMouseout?: ((payload: MouseEvent) => void) | undefined;
+onMouseover?: ((payload: MouseEvent) => void) | undefined;
+onMouseup?: ((payload: MouseEvent) => void) | undefined;
+onAbort?: ((payload: Event) => void) | undefined;
+onCanplay?: ((payload: Event) => void) | undefined;
+onCanplaythrough?: ((payload: Event) => void) | undefined;
+onDurationchange?: ((payload: Event) => void) | undefined;
+onEmptied?: ((payload: Event) => void) | undefined;
+onEncrypted?: ((payload: Event) => void) | undefined;
+onEnded?: ((payload: Event) => void) | undefined;
+onLoadeddata?: ((payload: Event) => void) | undefined;
+onLoadedmetadata?: ((payload: Event) => void) | undefined;
+onLoadstart?: ((payload: Event) => void) | undefined;
+onPause?: ((payload: Event) => void) | undefined;
+onPlay?: ((payload: Event) => void) | undefined;
+onPlaying?: ((payload: Event) => void) | undefined;
+onProgress?: ((payload: Event) => void) | undefined;
+onRatechange?: ((payload: Event) => void) | undefined;
+onSeeked?: ((payload: Event) => void) | undefined;
+onSeeking?: ((payload: Event) => void) | undefined;
+onStalled?: ((payload: Event) => void) | undefined;
+onSuspend?: ((payload: Event) => void) | undefined;
+onTimeupdate?: ((payload: Event) => void) | undefined;
+onVolumechange?: ((payload: Event) => void) | undefined;
+onWaiting?: ((payload: Event) => void) | undefined;
+onSelect?: ((payload: Event) => void) | undefined;
+onScroll?: ((payload: Event) => void) | undefined;
+onScrollend?: ((payload: Event) => void) | undefined;
+onTouchcancel?: ((payload: TouchEvent) => void) | undefined;
+onTouchend?: ((payload: TouchEvent) => void) | undefined;
+onTouchmove?: ((payload: TouchEvent) => void) | undefined;
+onTouchstart?: ((payload: TouchEvent) => void) | undefined;
+onPointerdown?: ((payload: PointerEvent) => void) | undefined;
+onPointermove?: ((payload: PointerEvent) => void) | undefined;
+onPointerup?: ((payload: PointerEvent) => void) | undefined;
+onPointercancel?: ((payload: PointerEvent) => void) | undefined;
+onPointerenter?: ((payload: PointerEvent) => void) | undefined;
+onPointerleave?: ((payload: PointerEvent) => void) | undefined;
+onPointerover?: ((payload: PointerEvent) => void) | undefined;
+onPointerout?: ((payload: PointerEvent) => void) | undefined;
+onWheel?: ((payload: WheelEvent) => void) | undefined;
+onAnimationstart?: ((payload: AnimationEvent) => void) | undefined;
+onAnimationend?: ((payload: AnimationEvent) => void) | undefined;
+onAnimationiteration?: ((payload: AnimationEvent) => void) | undefined;
+onTransitionend?: ((payload: TransitionEvent) => void) | undefined;
+onTransitionstart?: ((payload: TransitionEvent) => void) | undefined;
+}, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
+onDOMBeforeInput?: ((event: InputEvent) => void) | undefined;
+role?: string | undefined;
+readOnly: boolean;
+placeholder?: string | undefined;
+style?: CSSProperties | undefined;
+scrollSelectionIntoView: (editor: DOMEditor, domRange: globalThis.Range) => void;
+is: string;
+innerHTML?: string | undefined;
+class?: any;
+accesskey?: string | undefined;
+contenteditable?: ((boolean | "false" | "true") | "inherit" | "plaintext-only") | undefined;
+contextmenu?: string | undefined;
+dir?: string | undefined;
+draggable?: (boolean | "false" | "true") | undefined;
+hidden?: ((boolean | "false" | "true") | "" | "hidden" | "until-found") | undefined;
+id?: string | undefined;
+inert?: (boolean | "false" | "true") | undefined;
+lang?: string | undefined;
+spellcheck?: (boolean | "false" | "true") | undefined;
+tabindex?: (string | number) | undefined;
+title?: string | undefined;
+translate?: "yes" | "no" | undefined;
+radiogroup?: string | undefined;
+about?: string | undefined;
+datatype?: string | undefined;
+inlist?: any;
+prefix?: string | undefined;
+property?: string | undefined;
+resource?: string | undefined;
+typeof?: string | undefined;
+vocab?: string | undefined;
+autocapitalize?: string | undefined;
+autocorrect?: string | undefined;
+autosave?: string | undefined;
+color?: string | undefined;
+itemprop?: string | undefined;
+itemscope?: (boolean | "false" | "true") | undefined;
+itemtype?: string | undefined;
+itemid?: string | undefined;
+itemref?: string | undefined;
+results?: (string | number) | undefined;
+security?: string | undefined;
+unselectable?: "on" | "off" | undefined;
+inputmode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+'aria-activedescendant'?: string | undefined;
+'aria-atomic'?: (boolean | "false" | "true") | undefined;
+'aria-autocomplete'?: "none" | "inline" | "list" | "both" | undefined;
+'aria-busy'?: (boolean | "false" | "true") | undefined;
+'aria-checked'?: ((boolean | "false" | "true") | "mixed") | undefined;
+'aria-colcount'?: (string | number) | undefined;
+'aria-colindex'?: (string | number) | undefined;
+'aria-colspan'?: (string | number) | undefined;
+'aria-controls'?: string | undefined;
+'aria-current'?: ((boolean | "false" | "true") | "page" | "step" | "location" | "date" | "time") | undefined;
+'aria-describedby'?: string | undefined;
+'aria-details'?: string | undefined;
+'aria-disabled'?: (boolean | "false" | "true") | undefined;
+'aria-dropeffect'?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+'aria-errormessage'?: string | undefined;
+'aria-expanded'?: (boolean | "false" | "true") | undefined;
+'aria-flowto'?: string | undefined;
+'aria-grabbed'?: (boolean | "false" | "true") | undefined;
+'aria-haspopup'?: ((boolean | "false" | "true") | "menu" | "listbox" | "tree" | "grid" | "dialog") | undefined;
+'aria-hidden'?: (boolean | "false" | "true") | undefined;
+'aria-invalid'?: ((boolean | "false" | "true") | "grammar" | "spelling") | undefined;
+'aria-keyshortcuts'?: string | undefined;
+'aria-label'?: string | undefined;
+'aria-labelledby'?: string | undefined;
+'aria-level'?: (string | number) | undefined;
+'aria-live'?: "off" | "assertive" | "polite" | undefined;
+'aria-modal'?: (boolean | "false" | "true") | undefined;
+'aria-multiline'?: (boolean | "false" | "true") | undefined;
+'aria-multiselectable'?: (boolean | "false" | "true") | undefined;
+'aria-orientation'?: "horizontal" | "vertical" | undefined;
+'aria-owns'?: string | undefined;
+'aria-placeholder'?: string | undefined;
+'aria-posinset'?: (string | number) | undefined;
+'aria-pressed'?: ((boolean | "false" | "true") | "mixed") | undefined;
+'aria-readonly'?: (boolean | "false" | "true") | undefined;
+'aria-relevant'?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+'aria-required'?: (boolean | "false" | "true") | undefined;
+'aria-roledescription'?: string | undefined;
+'aria-rowcount'?: (string | number) | undefined;
+'aria-rowindex'?: (string | number) | undefined;
+'aria-rowspan'?: (string | number) | undefined;
+'aria-selected'?: (boolean | "false" | "true") | undefined;
+'aria-setsize'?: (string | number) | undefined;
+'aria-sort'?: "none" | "ascending" | "descending" | "other" | undefined;
+'aria-valuemax'?: (string | number) | undefined;
+'aria-valuemin'?: (string | number) | undefined;
+'aria-valuenow'?: (string | number) | undefined;
+'aria-valuetext'?: string | undefined;
+onCopy?: ((payload: ClipboardEvent) => void) | undefined;
+onCut?: ((payload: ClipboardEvent) => void) | undefined;
+onPaste?: ((payload: ClipboardEvent) => void) | undefined;
+onCompositionend?: ((payload: CompositionEvent) => void) | undefined;
+onCompositionstart?: ((payload: CompositionEvent) => void) | undefined;
+onCompositionupdate?: ((payload: CompositionEvent) => void) | undefined;
+onDrag?: ((payload: DragEvent) => void) | undefined;
+onDragend?: ((payload: DragEvent) => void) | undefined;
+onDragenter?: ((payload: DragEvent) => void) | undefined;
+onDragexit?: ((payload: DragEvent) => void) | undefined;
+onDragleave?: ((payload: DragEvent) => void) | undefined;
+onDragover?: ((payload: DragEvent) => void) | undefined;
+onDragstart?: ((payload: DragEvent) => void) | undefined;
+onDrop?: ((payload: DragEvent) => void) | undefined;
+onFocus?: ((payload: FocusEvent) => void) | undefined;
+onFocusin?: ((payload: FocusEvent) => void) | undefined;
+onFocusout?: ((payload: FocusEvent) => void) | undefined;
+onBlur?: ((payload: FocusEvent) => void) | undefined;
+onChange?: ((payload: Event) => void) | undefined;
+onBeforeinput?: ((payload: Event) => void) | undefined;
+onInput?: ((payload: Event) => void) | undefined;
+onReset?: ((payload: Event) => void) | undefined;
+onSubmit?: ((payload: Event) => void) | undefined;
+onInvalid?: ((payload: Event) => void) | undefined;
+onLoad?: ((payload: Event) => void) | undefined;
+onError?: ((payload: Event) => void) | undefined;
+onKeydown?: ((payload: KeyboardEvent) => void) | undefined;
+onKeypress?: ((payload: KeyboardEvent) => void) | undefined;
+onKeyup?: ((payload: KeyboardEvent) => void) | undefined;
+onAuxclick?: ((payload: MouseEvent) => void) | undefined;
+onClick?: ((payload: MouseEvent) => void) | undefined;
+onContextmenu?: ((payload: MouseEvent) => void) | undefined;
+onDblclick?: ((payload: MouseEvent) => void) | undefined;
+onMousedown?: ((payload: MouseEvent) => void) | undefined;
+onMouseenter?: ((payload: MouseEvent) => void) | undefined;
+onMouseleave?: ((payload: MouseEvent) => void) | undefined;
+onMousemove?: ((payload: MouseEvent) => void) | undefined;
+onMouseout?: ((payload: MouseEvent) => void) | undefined;
+onMouseover?: ((payload: MouseEvent) => void) | undefined;
+onMouseup?: ((payload: MouseEvent) => void) | undefined;
+onAbort?: ((payload: Event) => void) | undefined;
+onCanplay?: ((payload: Event) => void) | undefined;
+onCanplaythrough?: ((payload: Event) => void) | undefined;
+onDurationchange?: ((payload: Event) => void) | undefined;
+onEmptied?: ((payload: Event) => void) | undefined;
+onEncrypted?: ((payload: Event) => void) | undefined;
+onEnded?: ((payload: Event) => void) | undefined;
+onLoadeddata?: ((payload: Event) => void) | undefined;
+onLoadedmetadata?: ((payload: Event) => void) | undefined;
+onLoadstart?: ((payload: Event) => void) | undefined;
+onPause?: ((payload: Event) => void) | undefined;
+onPlay?: ((payload: Event) => void) | undefined;
+onPlaying?: ((payload: Event) => void) | undefined;
+onProgress?: ((payload: Event) => void) | undefined;
+onRatechange?: ((payload: Event) => void) | undefined;
+onSeeked?: ((payload: Event) => void) | undefined;
+onSeeking?: ((payload: Event) => void) | undefined;
+onStalled?: ((payload: Event) => void) | undefined;
+onSuspend?: ((payload: Event) => void) | undefined;
+onTimeupdate?: ((payload: Event) => void) | undefined;
+onVolumechange?: ((payload: Event) => void) | undefined;
+onWaiting?: ((payload: Event) => void) | undefined;
+onSelect?: ((payload: Event) => void) | undefined;
+onScroll?: ((payload: Event) => void) | undefined;
+onScrollend?: ((payload: Event) => void) | undefined;
+onTouchcancel?: ((payload: TouchEvent) => void) | undefined;
+onTouchend?: ((payload: TouchEvent) => void) | undefined;
+onTouchmove?: ((payload: TouchEvent) => void) | undefined;
+onTouchstart?: ((payload: TouchEvent) => void) | undefined;
+onPointerdown?: ((payload: PointerEvent) => void) | undefined;
+onPointermove?: ((payload: PointerEvent) => void) | undefined;
+onPointerup?: ((payload: PointerEvent) => void) | undefined;
+onPointercancel?: ((payload: PointerEvent) => void) | undefined;
+onPointerenter?: ((payload: PointerEvent) => void) | undefined;
+onPointerleave?: ((payload: PointerEvent) => void) | undefined;
+onPointerover?: ((payload: PointerEvent) => void) | undefined;
+onPointerout?: ((payload: PointerEvent) => void) | undefined;
+onWheel?: ((payload: WheelEvent) => void) | undefined;
+onAnimationstart?: ((payload: AnimationEvent) => void) | undefined;
+onAnimationend?: ((payload: AnimationEvent) => void) | undefined;
+onAnimationiteration?: ((payload: AnimationEvent) => void) | undefined;
+onTransitionend?: ((payload: TransitionEvent) => void) | undefined;
+onTransitionstart?: ((payload: TransitionEvent) => void) | undefined;
+}> & Readonly<{}>, {
+style: Record<string, any>;
+is: string;
+scrollSelectionIntoView: Function;
+readOnly: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare type Editor = ExtendedType<'Editor', BaseEditor>;
+
+export declare const Editor: EditorInterface;
+
+export declare const EDITOR_TO_ELEMENT: toRawWeakMap<Editor, HTMLElement>;
+
+export declare const EDITOR_TO_FORCE_RENDER: toRawWeakMap<Editor, () => void>;
+
+export declare const EDITOR_TO_KEY_TO_ELEMENT: toRawWeakMap<Editor, toRawWeakMap<Key, HTMLElement>>;
+
+/**
+ * Weak map for associating the context `onChange` context with the plugin.
+ */
+export declare const EDITOR_TO_ON_CHANGE: toRawWeakMap<DOMEditor, (options?: {
+    operation?: Operation;
+}) => void>;
+
+export declare const EDITOR_TO_PENDING_ACTION: toRawWeakMap<Editor, Action | null>;
+
+/**
+ * Android input handling specific weak-maps
+ */
+export declare const EDITOR_TO_PENDING_DIFFS: toRawWeakMap<Editor, TextDiff[]>;
+
+export declare const EDITOR_TO_PENDING_INSERTION_MARKS: toRawWeakMap<Editor, Partial<Text_2> | null>;
+
+export declare const EDITOR_TO_PENDING_SELECTION: toRawWeakMap<Editor, Range_2 | null>;
+
+export declare const EDITOR_TO_PLACEHOLDER_ELEMENT: toRawWeakMap<Editor, HTMLElement>;
+
+/**
+ * Weak maps for saving pending state on composition stage.
+ */
+export declare const EDITOR_TO_SCHEDULE_FLUSH: toRawWeakMap<Editor, () => void>;
+
+export declare const EDITOR_TO_USER_MARKS: toRawWeakMap<Editor, Partial<Text_2> | null>;
+
+export declare const EDITOR_TO_USER_SELECTION: toRawWeakMap<Editor, RangeRef | null>;
+
+/**
+ * Weak maps that allow us to go between Slate nodes and DOM nodes. These
+ * are used to resolve DOM event-related logic into Slate actions.
+ */
+export declare const EDITOR_TO_WINDOW: toRawWeakMap<Editor, Window>;
+
+export declare interface EditorAboveOptions<T extends Ancestor> {
+    at?: Location_2;
+    match?: NodeMatch<T>;
+    mode?: MaximizeMode;
+    voids?: boolean;
+}
+
+export declare interface EditorAfterOptions {
+    distance?: number;
+    unit?: TextUnitAdjustment;
+    voids?: boolean;
+}
+
+export declare interface EditorBeforeOptions {
+    distance?: number;
+    unit?: TextUnitAdjustment;
+    voids?: boolean;
+}
+
+export declare interface EditorDirectedDeletionOptions {
+    unit?: TextUnit;
+}
+
+export declare interface EditorElementReadOnlyOptions {
+    at?: Location_2;
+    mode?: MaximizeMode;
+    voids?: boolean;
+}
+
+export declare interface EditorFragmentDeletionOptions {
+    direction?: TextDirection;
+}
+
+export declare interface EditorInterface {
+    /**
+     * Get the ancestor above a location in the document.
+     */
+    above: <T extends Ancestor>(editor: Editor, options?: EditorAboveOptions<T>) => NodeEntry<T> | undefined;
+    /**
+     * Add a custom property to the leaf text nodes in the current selection.
+     *
+     * If the selection is currently collapsed, the marks will be added to the
+     * `editor.marks` property instead, and applied when text is inserted next.
+     */
+    addMark: (editor: Editor, key: string, value: any) => void;
+    /**
+     * Get the point after a location.
+     */
+    after: (editor: Editor, at: Location_2, options?: EditorAfterOptions) => Point | undefined;
+    /**
+     * Get the point before a location.
+     */
+    before: (editor: Editor, at: Location_2, options?: EditorBeforeOptions) => Point | undefined;
+    /**
+     * Delete content in the editor backward from the current selection.
+     */
+    deleteBackward: (editor: Editor, options?: EditorDirectedDeletionOptions) => void;
+    /**
+     * Delete content in the editor forward from the current selection.
+     */
+    deleteForward: (editor: Editor, options?: EditorDirectedDeletionOptions) => void;
+    /**
+     * Delete the content in the current selection.
+     */
+    deleteFragment: (editor: Editor, options?: EditorFragmentDeletionOptions) => void;
+    /**
+     * Get the start and end points of a location.
+     */
+    edges: (editor: Editor, at: Location_2) => [Point, Point];
+    /**
+     * Match a read-only element in the current branch of the editor.
+     */
+    elementReadOnly: (editor: Editor, options?: EditorElementReadOnlyOptions) => NodeEntry<Element_2> | undefined;
+    /**
+     * Get the end point of a location.
+     */
+    end: (editor: Editor, at: Location_2) => Point;
+    /**
+     * Get the first node at a location.
+     */
+    first: (editor: Editor, at: Location_2) => NodeEntry;
+    /**
+     * Get the fragment at a location.
+     */
+    fragment: (editor: Editor, at: Location_2) => Descendant[];
+    /**
+     * Check if a node has block children.
+     */
+    hasBlocks: (editor: Editor, element: Element_2) => boolean;
+    /**
+     * Check if a node has inline and text children.
+     */
+    hasInlines: (editor: Editor, element: Element_2) => boolean;
+    hasPath: (editor: Editor, path: Path) => boolean;
+    /**
+     * Check if a node has text children.
+     */
+    hasTexts: (editor: Editor, element: Element_2) => boolean;
+    /**
+     * Insert a block break at the current selection.
+     *
+     * If the selection is currently expanded, it will be deleted first.
+     */
+    insertBreak: (editor: Editor) => void;
+    /**
+     * Inserts a fragment
+     * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
+     */
+    insertFragment: (editor: Editor, fragment: Node_2[], options?: TextInsertFragmentOptions) => void;
+    /**
+     * Atomically inserts `nodes`
+     * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
+     */
+    insertNode: <T extends Node_2>(editor: Editor, node: Node_2, options?: NodeInsertNodesOptions<T>) => void;
+    /**
+     * Insert a soft break at the current selection.
+     *
+     * If the selection is currently expanded, it will be deleted first.
+     */
+    insertSoftBreak: (editor: Editor) => void;
+    /**
+     * Insert a string of text
+     * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
+     */
+    insertText: (editor: Editor, text: string, options?: TextInsertTextOptions) => void;
+    /**
+     * Check if a value is a block `Element` object.
+     */
+    isBlock: (editor: Editor, value: Element_2) => boolean;
+    /**
+     * Check if a point is an edge of a location.
+     */
+    isEdge: (editor: Editor, point: Point, at: Location_2) => boolean;
+    /**
+     * Check if a value is an `Editor` object.
+     */
+    isEditor: (value: any) => value is Editor;
+    /**
+     * Check if a value is a read-only `Element` object.
+     */
+    isElementReadOnly: (editor: Editor, element: Element_2) => boolean;
+    /**
+     * Check if an element is empty, accounting for void nodes.
+     */
+    isEmpty: (editor: Editor, element: Element_2) => boolean;
+    /**
+     * Check if a point is the end point of a location.
+     */
+    isEnd: (editor: Editor, point: Point, at: Location_2) => boolean;
+    /**
+     * Check if a value is an inline `Element` object.
+     */
+    isInline: (editor: Editor, value: Element_2) => boolean;
+    /**
+     * Check if the editor is currently normalizing after each operation.
+     */
+    isNormalizing: (editor: Editor) => boolean;
+    /**
+     * Check if a value is a selectable `Element` object.
+     */
+    isSelectable: (editor: Editor, element: Element_2) => boolean;
+    /**
+     * Check if a point is the start point of a location.
+     */
+    isStart: (editor: Editor, point: Point, at: Location_2) => boolean;
+    /**
+     * Check if a value is a void `Element` object.
+     */
+    isVoid: (editor: Editor, value: Element_2) => boolean;
+    /**
+     * Get the last node at a location.
+     */
+    last: (editor: Editor, at: Location_2) => NodeEntry;
+    /**
+     * Get the leaf text node at a location.
+     */
+    leaf: (editor: Editor, at: Location_2, options?: EditorLeafOptions) => NodeEntry<Text_2>;
+    /**
+     * Iterate through all of the levels at a location.
+     */
+    levels: <T extends Node_2>(editor: Editor, options?: EditorLevelsOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
+    /**
+     * Get the marks that would be added to text at the current selection.
+     */
+    marks: (editor: Editor) => Omit<Text_2, 'text'> | null;
+    /**
+     * Get the matching node in the branch of the document after a location.
+     */
+    next: <T extends Descendant>(editor: Editor, options?: EditorNextOptions<T>) => NodeEntry<T> | undefined;
+    /**
+     * Get the node at a location.
+     */
+    node: (editor: Editor, at: Location_2, options?: EditorNodeOptions) => NodeEntry;
+    /**
+     * Iterate through all of the nodes in the Editor.
+     */
+    nodes: <T extends Node_2>(editor: Editor, options?: EditorNodesOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
+    /**
+     * Normalize any dirty objects in the editor.
+     */
+    normalize: (editor: Editor, options?: EditorNormalizeOptions) => void;
+    /**
+     * Get the parent node of a location.
+     */
+    parent: (editor: Editor, at: Location_2, options?: EditorParentOptions) => NodeEntry<Ancestor>;
+    /**
+     * Get the path of a location.
+     */
+    path: (editor: Editor, at: Location_2, options?: EditorPathOptions) => Path;
+    /**
+     * Create a mutable ref for a `Path` object, which will stay in sync as new
+     * operations are applied to the editor.
+     */
+    pathRef: (editor: Editor, path: Path, options?: EditorPathRefOptions) => PathRef;
+    /**
+     * Get the set of currently tracked path refs of the editor.
+     */
+    pathRefs: (editor: Editor) => Set<PathRef>;
+    /**
+     * Get the start or end point of a location.
+     */
+    point: (editor: Editor, at: Location_2, options?: EditorPointOptions) => Point;
+    /**
+     * Create a mutable ref for a `Point` object, which will stay in sync as new
+     * operations are applied to the editor.
+     */
+    pointRef: (editor: Editor, point: Point, options?: EditorPointRefOptions) => PointRef;
+    /**
+     * Get the set of currently tracked point refs of the editor.
+     */
+    pointRefs: (editor: Editor) => Set<PointRef>;
+    /**
+     * Return all the positions in `at` range where a `Point` can be placed.
+     *
+     * By default, moves forward by individual offsets at a time, but
+     * the `unit` option can be used to to move by character, word, line, or block.
+     *
+     * The `reverse` option can be used to change iteration direction.
+     *
+     * Note: By default void nodes are treated as a single point and iteration
+     * will not happen inside their content unless you pass in true for the
+     * `voids` option, then iteration will occur.
+     */
+    positions: (editor: Editor, options?: EditorPositionsOptions) => Generator<Point, void, undefined>;
+    /**
+     * Get the matching node in the branch of the document before a location.
+     */
+    previous: <T extends Node_2>(editor: Editor, options?: EditorPreviousOptions<T>) => NodeEntry<T> | undefined;
+    /**
+     * Get a range of a location.
+     */
+    range: (editor: Editor, at: Location_2, to?: Location_2) => Range_2;
+    /**
+     * Create a mutable ref for a `Range` object, which will stay in sync as new
+     * operations are applied to the editor.
+     */
+    rangeRef: (editor: Editor, range: Range_2, options?: EditorRangeRefOptions) => RangeRef;
+    /**
+     * Get the set of currently tracked range refs of the editor.
+     */
+    rangeRefs: (editor: Editor) => Set<RangeRef>;
+    /**
+     * Remove a custom property from all of the leaf text nodes in the current
+     * selection.
+     *
+     * If the selection is currently collapsed, the removal will be stored on
+     * `editor.marks` and applied to the text inserted next.
+     */
+    removeMark: (editor: Editor, key: string) => void;
+    /**
+     * Manually set if the editor should currently be normalizing.
+     *
+     * Note: Using this incorrectly can leave the editor in an invalid state.
+     *
+     */
+    setNormalizing: (editor: Editor, isNormalizing: boolean) => void;
+    /**
+     * Get the start point of a location.
+     */
+    start: (editor: Editor, at: Location_2) => Point;
+    /**
+     * Get the text string content of a location.
+     *
+     * Note: by default the text of void nodes is considered to be an empty
+     * string, regardless of content, unless you pass in true for the voids option
+     */
+    string: (editor: Editor, at: Location_2, options?: EditorStringOptions) => string;
+    /**
+     * Convert a range into a non-hanging one.
+     */
+    unhangRange: (editor: Editor, range: Range_2, options?: EditorUnhangRangeOptions) => Range_2;
+    /**
+     * Match a void node in the current branch of the editor.
+     */
+    void: (editor: Editor, options?: EditorVoidOptions) => NodeEntry<Element_2> | undefined;
+    /**
+     * Call a function, deferring normalization until after it completes.
+     */
+    withoutNormalizing: (editor: Editor, fn: () => void) => void;
+    /**
+     *  Call a function, Determine whether or not remove the previous node when merge.
+     */
+    shouldMergeNodesRemovePrevNode: (editor: Editor, prevNodeEntry: NodeEntry, curNodeEntry: NodeEntry) => boolean;
+}
+
+export declare interface EditorLeafOptions {
+    depth?: number;
+    edge?: LeafEdge;
+}
+
+export declare interface EditorLevelsOptions<T extends Node_2> {
+    at?: Location_2;
+    match?: NodeMatch<T>;
+    reverse?: boolean;
+    voids?: boolean;
+}
+
+export declare type EditorMarks = Omit<Text_2, 'text'>;
+
+export declare interface EditorNextOptions<T extends Descendant> {
+    at?: Location_2;
+    match?: NodeMatch<T>;
+    mode?: SelectionMode_2;
+    voids?: boolean;
+}
+
+export declare interface EditorNodeOptions {
+    depth?: number;
+    edge?: LeafEdge;
+}
+
+export declare interface EditorNodesOptions<T extends Node_2> {
+    at?: Location_2 | Span;
+    match?: NodeMatch<T>;
+    mode?: SelectionMode_2;
+    universal?: boolean;
+    reverse?: boolean;
+    voids?: boolean;
+    ignoreNonSelectable?: boolean;
+}
+
+export declare interface EditorNormalizeOptions {
+    force?: boolean;
+    operation?: Operation;
+}
+
+export declare interface EditorParentOptions {
+    depth?: number;
+    edge?: LeafEdge;
+}
+
+export declare interface EditorPathOptions {
+    depth?: number;
+    edge?: LeafEdge;
+}
+
+export declare interface EditorPathRefOptions {
+    affinity?: TextDirection | null;
+}
+
+export declare interface EditorPointOptions {
+    edge?: LeafEdge;
+}
+
+export declare interface EditorPointRefOptions {
+    affinity?: TextDirection | null;
+}
+
+export declare interface EditorPositionsOptions {
+    at?: Location_2;
+    unit?: TextUnitAdjustment;
+    reverse?: boolean;
+    voids?: boolean;
+    ignoreNonSelectable?: boolean;
+}
+
+export declare interface EditorPreviousOptions<T extends Node_2> {
+    at?: Location_2;
+    match?: NodeMatch<T>;
+    mode?: SelectionMode_2;
+    voids?: boolean;
+}
+
+export declare interface EditorRangeRefOptions {
+    affinity?: RangeDirection | null;
+}
+
+export declare interface EditorStringOptions {
+    voids?: boolean;
+}
+
+export declare interface EditorUnhangRangeOptions {
+    voids?: boolean;
+}
+
+export declare interface EditorVoidOptions {
+    at?: Location_2;
+    mode?: MaximizeMode;
+    voids?: boolean;
+}
+
+declare type Element_2 = ExtendedType<'Element', BaseElement>;
+
+declare const Element_2: ElementInterface;
+export { Element_2 as Element }
+
+export declare const ELEMENT_TO_NODE: toRawWeakMap<HTMLElement, Node_2>;
+
+/**
+ * `ElementEntry` objects refer to an `Element` and the `Path` where it can be
+ * found inside a root node.
+ */
+export declare type ElementEntry = [Element_2, Path];
+
+export declare interface ElementInterface {
+    /**
+     * Check if a value implements the 'Ancestor' interface.
+     */
+    isAncestor: (value: any) => value is Ancestor;
+    /**
+     * Check if a value implements the `Element` interface.
+     */
+    isElement: (value: any) => value is Element_2;
+    /**
+     * Check if a value is an array of `Element` objects.
+     */
+    isElementList: (value: any) => value is Element_2[];
+    /**
+     * Check if a set of props is a partial of Element.
+     */
+    isElementProps: (props: any) => props is Partial<Element_2>;
+    /**
+     * Check if a value implements the `Element` interface and has elementKey with selected value.
+     * Default it check to `type` key value
+     */
+    isElementType: <T extends Element_2>(value: any, elementVal: string, elementKey?: string) => value is T;
+    /**
+     * Check if an element matches set of properties.
+     *
+     * Note: this checks custom properties, and it does not ensure that any
+     * children are equivalent.
+     */
+    matches: (element: Element_2, props: Partial<Element_2>) => boolean;
+}
+
+export declare const elementReadOnly: EditorInterface['elementReadOnly'];
+
+export declare const end: EditorInterface['end'];
+
+/**
+ * Extendable Custom Types Interface
+ */
+declare type ExtendableTypes = 'Editor' | 'Element' | 'Text' | 'Selection' | 'Range' | 'Point' | 'Operation' | 'InsertNodeOperation' | 'InsertTextOperation' | 'MergeNodeOperation' | 'MoveNodeOperation' | 'RemoveNodeOperation' | 'RemoveTextOperation' | 'SetNodeOperation' | 'SetSelectionOperation' | 'SplitNodeOperation';
+
+export declare type ExtendedType<K extends ExtendableTypes, B> = unknown extends CustomTypes[K] ? B : CustomTypes[K];
+
+export declare const first: EditorInterface['first'];
+
+export declare const fragment: EditorInterface['fragment'];
+
+declare interface GeneralTransforms {
+    /**
+     * Transform the editor by an operation.
+     */
+    transform: (editor: Editor, op: Operation) => void;
+}
+
+declare const GeneralTransforms: GeneralTransforms;
+
+/**
+ * Retrieves the deepest active element in the DOM, considering nested shadow DOMs.
+ */
+export declare const getActiveElement: () => Element | null;
+
+/**
+ * Returns the host window of a DOM node
+ */
+export declare const getDefaultView: (value: any) => Window | null;
+
+/**
+ * Get the "dirty" paths generated from an operation.
+ */
+export declare const getDirtyPaths: WithEditorFirstArg<Editor['getDirtyPaths']>;
+
+export declare const getFragment: WithEditorFirstArg<Editor['getFragment']>;
+
+/**
+ * Get the dom selection from Shadow Root if possible, otherwise from the document
+ */
+declare const getSelection_2: (root: Document | ShadowRoot) => Selection | null;
+export { getSelection_2 as getSelection }
+
+export declare const getVoid: EditorInterface['void'];
+
+export declare const HAS_BEFORE_INPUT_SUPPORT: boolean;
+
+export declare const hasBlocks: EditorInterface['hasBlocks'];
+
+export declare const hasInlines: EditorInterface['hasInlines'];
+
+export declare const hasPath: EditorInterface['hasPath'];
+
+/**
+ * Determines whether the active element is nested within a shadowRoot
+ */
+export declare const hasShadowRoot: (node: Node | null) => boolean;
+
+export declare const hasTexts: EditorInterface['hasTexts'];
+
+/**
+ * Hotkeys.
+ */
+export declare const Hotkeys: {
+    isBold: (event: KeyboardEvent) => boolean;
+    isCompose: (event: KeyboardEvent) => boolean;
+    isMoveBackward: (event: KeyboardEvent) => boolean;
+    isMoveForward: (event: KeyboardEvent) => boolean;
+    isDeleteBackward: (event: KeyboardEvent) => boolean;
+    isDeleteForward: (event: KeyboardEvent) => boolean;
+    isDeleteLineBackward: (event: KeyboardEvent) => boolean;
+    isDeleteLineForward: (event: KeyboardEvent) => boolean;
+    isDeleteWordBackward: (event: KeyboardEvent) => boolean;
+    isDeleteWordForward: (event: KeyboardEvent) => boolean;
+    isExtendBackward: (event: KeyboardEvent) => boolean;
+    isExtendForward: (event: KeyboardEvent) => boolean;
+    isExtendLineBackward: (event: KeyboardEvent) => boolean;
+    isExtendLineForward: (event: KeyboardEvent) => boolean;
+    isItalic: (event: KeyboardEvent) => boolean;
+    isMoveLineBackward: (event: KeyboardEvent) => boolean;
+    isMoveLineForward: (event: KeyboardEvent) => boolean;
+    isMoveWordBackward: (event: KeyboardEvent) => boolean;
+    isMoveWordForward: (event: KeyboardEvent) => boolean;
+    isRedo: (event: KeyboardEvent) => boolean;
+    isSoftBreak: (event: KeyboardEvent) => boolean;
+    isSplitBlock: (event: KeyboardEvent) => boolean;
+    isTransposeCharacter: (event: KeyboardEvent) => boolean;
+    isUndo: (event: KeyboardEvent) => boolean;
+};
+
+export declare const insertBreak: EditorInterface['insertBreak'];
+
+export declare const insertFragment: TextTransforms['insertFragment'];
+
+export declare const insertNode: EditorInterface['insertNode'];
+
+export declare type InsertNodeOperation = ExtendedType<'InsertNodeOperation', BaseInsertNodeOperation>;
+
+export declare const insertNodes: NodeTransforms['insertNodes'];
+
+export declare const insertSoftBreak: EditorInterface['insertSoftBreak'];
+
+export declare const insertText: EditorInterface['insertText'];
+
+export declare type InsertTextOperation = ExtendedType<'InsertTextOperation', BaseInsertTextOperation>;
+
+export declare const IS_ANDROID: boolean;
+
+export declare const IS_CHROME: boolean;
+
+export declare const IS_COMPOSING: toRawWeakMap<Editor, boolean>;
+
+export declare const IS_FIREFOX: boolean;
+
+export declare const IS_FIREFOX_LEGACY: boolean;
+
+export declare const IS_FOCUSED: toRawWeakMap<Editor, boolean>;
+
+export declare const IS_IOS: boolean;
+
+/**
+ * Two weak maps that allow us rebuild a path given a node. They are populated
+ * at render time such that after a render occurs we can always backtrack.
+ */
+export declare const IS_NODE_MAP_DIRTY: toRawWeakMap<Editor, boolean>;
+
+/**
+ * Weak maps for storing editor-related state.
+ */
+export declare const IS_READ_ONLY: toRawWeakMap<Editor, boolean>;
+
+export declare const IS_UC_MOBILE: boolean;
+
+export declare const IS_WEBKIT: boolean;
+
+export declare const IS_WECHATBROWSER: boolean;
+
+/**
+ * @returns `true` if `otherNode` is after `node` in the document; otherwise, `false`.
+ */
+export declare const isAfter: (node: DOMNode_3, otherNode: DOMNode_3) => boolean;
+
+/**
+ * @returns `true` if `otherNode` is before `node` in the document; otherwise, `false`.
+ */
+export declare const isBefore: (node: DOMNode_3, otherNode: DOMNode_3) => boolean;
+
+export declare const isBlock: EditorInterface['isBlock'];
+
+/**
+ * Check if a DOM node is an element node.
+ */
+export declare const isDOMElement: (value: any) => value is DOMElement_2;
+
+/**
+ * Check if a value is a DOM node.
+ */
+export declare const isDOMNode: (value: any) => value is DOMNode_3;
+
+/**
+ * Check if a value is a DOM selection.
+ */
+export declare const isDOMSelection: (value: any) => value is DOMSelection_3;
+
+export declare const isEdge: EditorInterface['isEdge'];
+
+export declare const isEditor: EditorInterface['isEditor'];
+
+/**
+ * Check if a list of decorator ranges are equal to another.
+ *
+ * PERF: this requires the two lists to also have the ranges inside them in the
+ * same order, but this is an okay constraint for us since decorations are
+ * kept in order, and the odd case where they aren't is okay to re-render for.
+ */
+export declare const isElementDecorationsEqual: (list: Range_2[], another: Range_2[]) => boolean;
+
+export declare const isEmpty: EditorInterface['isEmpty'];
+
+export declare const isEnd: EditorInterface['isEnd'];
+
+export declare const isNormalizing: EditorInterface['isNormalizing'];
+
+/**
+ * Checks whether a paste event is a plaintext-only event.
+ */
+export declare const isPlainTextOnlyPaste: (event: ClipboardEvent) => boolean | null;
+
+export declare const isStart: EditorInterface['isStart'];
+
+/**
+ * Check if a list of decorator ranges are equal to another.
+ *
+ * PERF: this requires the two lists to also have the ranges inside them in the
+ * same order, but this is an okay constraint for us since decorations are
+ * kept in order, and the odd case where they aren't is okay to re-render for.
+ */
+export declare const isTextDecorationsEqual: (list: Range_2[], another: Range_2[]) => boolean;
+
+/**
+ * Check whether a mutation originates from a editable element inside the editor.
+ */
+export declare const isTrackedMutation: (editor: DOMEditor, mutation: MutationRecord, batch: MutationRecord[]) => boolean;
+
+/**
+ * An auto-incrementing identifier for keys.
+ */
+/**
+ * A class that keeps track of a key string. We use a full class here because we
+ * want to be able to use them as keys in `WeakMap` objects.
+ */
+export declare class Key {
+    id: string;
+    constructor();
+}
+
+export declare const last: EditorInterface['last'];
+
+export declare const leaf: EditorInterface['leaf'];
+
+export declare type LeafEdge = 'start' | 'end';
+
+export declare function levels<T extends Node_2>(editor: Editor, options?: EditorLevelsOptions<T>): Generator<NodeEntry<T>, void, undefined>;
+
+export declare const liftNodes: NodeTransforms['liftNodes'];
+
+/**
+ * The `Location` interface is a union of the ways to refer to a specific
+ * location in a Slate document: paths, points or ranges.
+ *
+ * Methods will often accept a `Location` instead of requiring only a `Path`,
+ * `Point` or `Range`. This eliminates the need for developers to manage
+ * converting between the different interfaces in their own code base.
+ */
+declare type Location_2 = Path | Point | Range_2;
+
+declare const Location_2: LocationInterface;
+export { Location_2 as Location }
+
+export declare interface LocationInterface {
+    /**
+     * Check if a value implements the `Location` interface.
+     */
+    isLocation: (value: any) => value is Location_2;
+}
+
+export declare const MARK_PLACEHOLDER_SYMBOL: string;
+
+export declare const marks: EditorInterface['marks'];
+
+export declare type MaximizeMode = RangeMode | 'all';
+
+export declare type MergeNodeOperation = ExtendedType<'MergeNodeOperation', BaseMergeNodeOperation>;
+
+export declare const mergeNodes: NodeTransforms['mergeNodes'];
+
+/**
+ * Return a string diff that is equivalent to applying b after a spanning the range of
+ * both changes
+ */
+export declare function mergeStringDiffs(targetText: string, a: StringDiff, b: StringDiff): StringDiff | null;
+
+export declare const move: SelectionTransforms['move'];
+
+export declare type MoveNodeOperation = ExtendedType<'MoveNodeOperation', BaseMoveNodeOperation>;
+
+export declare const moveNodes: NodeTransforms['moveNodes'];
+
+export declare type MoveUnit = 'offset' | 'character' | 'word' | 'line';
+
+export declare const next: EditorInterface['next'];
+
+export declare const node: EditorInterface['node'];
+
+declare type Node_2 = Editor | Element_2 | Text_2;
+
+declare const Node_2: NodeInterface;
+export { Node_2 as Node }
+
+export declare const NODE_TO_ELEMENT: toRawWeakMap<Node_2, HTMLElement>;
+
+export declare const NODE_TO_INDEX: toRawWeakMap<Node_2, number>;
+
+export declare const NODE_TO_KEY: toRawWeakMap<Node_2, Key>;
+
+export declare const NODE_TO_PARENT: toRawWeakMap<Node_2, Ancestor>;
+
+export declare interface NodeAncestorsOptions {
+    reverse?: boolean;
+}
+
+export declare interface NodeChildrenOptions {
+    reverse?: boolean;
+}
+
+export declare interface NodeDescendantsOptions {
+    from?: Path;
+    to?: Path;
+    reverse?: boolean;
+    pass?: (node: NodeEntry) => boolean;
+}
+
+export declare interface NodeElementsOptions {
+    from?: Path;
+    to?: Path;
+    reverse?: boolean;
+    pass?: (node: NodeEntry) => boolean;
+}
+
+/**
+ * `NodeEntry` objects are returned when iterating over the nodes in a Slate
+ * document tree. They consist of the node and its `Path` relative to the root
+ * node in the document.
+ */
+export declare type NodeEntry<T extends Node_2 = Node_2> = [T, Path];
+
+declare interface NodeInsertNodesOptions<T extends Node_2> {
+    at?: Location_2;
+    match?: NodeMatch<T>;
+    mode?: RangeMode;
+    hanging?: boolean;
+    select?: boolean;
+    voids?: boolean;
+    batchDirty?: boolean;
+}
+
+export declare interface NodeInterface {
+    /**
+     * Get the node at a specific path, asserting that it's an ancestor node.
+     */
+    ancestor: (root: Node_2, path: Path) => Ancestor;
+    /**
+     * Return a generator of all the ancestor nodes above a specific path.
+     *
+     * By default the order is top-down, from highest to lowest ancestor in
+     * the tree, but you can pass the `reverse: true` option to go bottom-up.
+     */
+    ancestors: (root: Node_2, path: Path, options?: NodeAncestorsOptions) => Generator<NodeEntry<Ancestor>, void, undefined>;
+    /**
+     * Get the child of a node at a specific index.
+     */
+    child: (root: Node_2, index: number) => Descendant;
+    /**
+     * Iterate over the children of a node at a specific path.
+     */
+    children: (root: Node_2, path: Path, options?: NodeChildrenOptions) => Generator<NodeEntry<Descendant>, void, undefined>;
+    /**
+     * Get an entry for the common ancesetor node of two paths.
+     */
+    common: (root: Node_2, path: Path, another: Path) => NodeEntry;
+    /**
+     * Get the node at a specific path, asserting that it's a descendant node.
+     */
+    descendant: (root: Node_2, path: Path) => Descendant;
+    /**
+     * Return a generator of all the descendant node entries inside a root node.
+     */
+    descendants: (root: Node_2, options?: NodeDescendantsOptions) => Generator<NodeEntry<Descendant>, void, undefined>;
+    /**
+     * Return a generator of all the element nodes inside a root node. Each iteration
+     * will return an `ElementEntry` tuple consisting of `[Element, Path]`. If the
+     * root node is an element it will be included in the iteration as well.
+     */
+    elements: (root: Node_2, options?: NodeElementsOptions) => Generator<ElementEntry, void, undefined>;
+    /**
+     * Extract props from a Node.
+     */
+    extractProps: (node: Node_2) => NodeProps;
+    /**
+     * Get the first node entry in a root node from a path.
+     */
+    first: (root: Node_2, path: Path) => NodeEntry;
+    /**
+     * Get the sliced fragment represented by a range inside a root node.
+     */
+    fragment: (root: Node_2, range: Range_2) => Descendant[];
+    /**
+     * Get the descendant node referred to by a specific path. If the path is an
+     * empty array, it refers to the root node itself.
+     */
+    get: (root: Node_2, path: Path) => Node_2;
+    /**
+     * Similar to get, but returns undefined if the node does not exist.
+     */
+    getIf: (root: Node_2, path: Path) => Node_2 | undefined;
+    /**
+     * Check if a descendant node exists at a specific path.
+     */
+    has: (root: Node_2, path: Path) => boolean;
+    /**
+     * Check if a value implements the `Node` interface.
+     */
+    isNode: (value: any) => value is Node_2;
+    /**
+     * Check if a value is a list of `Node` objects.
+     */
+    isNodeList: (value: any) => value is Node_2[];
+    /**
+     * Get the last node entry in a root node from a path.
+     */
+    last: (root: Node_2, path: Path) => NodeEntry;
+    /**
+     * Get the node at a specific path, ensuring it's a leaf text node.
+     */
+    leaf: (root: Node_2, path: Path) => Text_2;
+    /**
+     * Return a generator of the in a branch of the tree, from a specific path.
+     *
+     * By default the order is top-down, from highest to lowest node in the tree,
+     * but you can pass the `reverse: true` option to go bottom-up.
+     */
+    levels: (root: Node_2, path: Path, options?: NodeLevelsOptions) => Generator<NodeEntry, void, undefined>;
+    /**
+     * Check if a node matches a set of props.
+     */
+    matches: (node: Node_2, props: Partial<Node_2>) => boolean;
+    /**
+     * Return a generator of all the node entries of a root node. Each entry is
+     * returned as a `[Node, Path]` tuple, with the path referring to the node's
+     * position inside the root node.
+     */
+    nodes: (root: Node_2, options?: NodeNodesOptions) => Generator<NodeEntry, void, undefined>;
+    /**
+     * Get the parent of a node at a specific path.
+     */
+    parent: (root: Node_2, path: Path) => Ancestor;
+    /**
+     * Get the concatenated text string of a node's content.
+     *
+     * Note that this will not include spaces or line breaks between block nodes.
+     * It is not a user-facing string, but a string for performing offset-related
+     * computations for a node.
+     */
+    string: (node: Node_2) => string;
+    /**
+     * Return a generator of all leaf text nodes in a root node.
+     */
+    texts: (root: Node_2, options?: NodeTextsOptions) => Generator<NodeEntry<Text_2>, void, undefined>;
+}
+
+export declare interface NodeLevelsOptions {
+    reverse?: boolean;
+}
+
+/**
+ * A helper type for narrowing matched nodes with a predicate.
+ */
+export declare type NodeMatch<T extends Node_2> = ((node: Node_2, path: Path) => node is T) | ((node: Node_2, path: Path) => boolean);
+
+export declare interface NodeNodesOptions {
+    from?: Path;
+    to?: Path;
+    reverse?: boolean;
+    pass?: (entry: NodeEntry) => boolean;
+}
+
+export declare type NodeOperation = InsertNodeOperation | MergeNodeOperation | MoveNodeOperation | RemoveNodeOperation | SetNodeOperation | SplitNodeOperation;
+
+/**
+ * Convenience type for returning the props of a node.
+ */
+export declare type NodeProps = Omit<Editor, 'children'> | Omit<Element_2, 'children'> | Omit<Text_2, 'text'>;
+
+export declare function nodes<T extends Node_2>(editor: Editor, options?: EditorNodesOptions<T>): Generator<NodeEntry<T>, void, undefined>;
+
+export declare interface NodeTextsOptions {
+    from?: Path;
+    to?: Path;
+    reverse?: boolean;
+    pass?: (node: NodeEntry) => boolean;
+}
+
+declare interface NodeTransforms {
+    /**
+     * Insert nodes in the editor
+     * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
+     */
+    insertNodes: <T extends Node_2>(editor: Editor, nodes: Node_2 | Node_2[], options?: NodeInsertNodesOptions<T>) => void;
+    /**
+     * Lift nodes at a specific location upwards in the document tree, splitting
+     * their parent in two if necessary.
+     */
+    liftNodes: <T extends Node_2>(editor: Editor, options?: {
+        at?: Location_2;
+        match?: NodeMatch<T>;
+        mode?: MaximizeMode;
+        voids?: boolean;
+    }) => void;
+    /**
+     * Merge a node at a location with the previous node of the same depth,
+     * removing any empty containing nodes after the merge if necessary.
+     */
+    mergeNodes: <T extends Node_2>(editor: Editor, options?: {
+        at?: Location_2;
+        match?: NodeMatch<T>;
+        mode?: RangeMode;
+        hanging?: boolean;
+        voids?: boolean;
+    }) => void;
+    /**
+     * Move the nodes at a location to a new location.
+     */
+    moveNodes: <T extends Node_2>(editor: Editor, options: {
+        at?: Location_2;
+        match?: NodeMatch<T>;
+        mode?: MaximizeMode;
+        to: Path;
+        voids?: boolean;
+    }) => void;
+    /**
+     * Remove the nodes at a specific location in the document.
+     */
+    removeNodes: <T extends Node_2>(editor: Editor, options?: {
+        at?: Location_2;
+        match?: NodeMatch<T>;
+        mode?: RangeMode;
+        hanging?: boolean;
+        voids?: boolean;
+    }) => void;
+    /**
+     * Set new properties on the nodes at a location.
+     */
+    setNodes: <T extends Node_2>(editor: Editor, props: Partial<T>, options?: {
+        at?: Location_2;
+        match?: NodeMatch<T>;
+        mode?: MaximizeMode;
+        hanging?: boolean;
+        split?: boolean;
+        voids?: boolean;
+        compare?: PropsCompare;
+        merge?: PropsMerge;
+    }) => void;
+    /**
+     * Split the nodes at a specific location.
+     */
+    splitNodes: <T extends Node_2>(editor: Editor, options?: {
+        at?: Location_2;
+        match?: NodeMatch<T>;
+        mode?: RangeMode;
+        always?: boolean;
+        height?: number;
+        voids?: boolean;
+    }) => void;
+    /**
+     * Unset properties on the nodes at a location.
+     */
+    unsetNodes: <T extends Node_2>(editor: Editor, props: string | string[], options?: {
+        at?: Location_2;
+        match?: NodeMatch<T>;
+        mode?: MaximizeMode;
+        hanging?: boolean;
+        split?: boolean;
+        voids?: boolean;
+    }) => void;
+    /**
+     * Unwrap the nodes at a location from a parent node, splitting the parent if
+     * necessary to ensure that only the content in the range is unwrapped.
+     */
+    unwrapNodes: <T extends Node_2>(editor: Editor, options?: {
+        at?: Location_2;
+        match?: NodeMatch<T>;
+        mode?: MaximizeMode;
+        split?: boolean;
+        voids?: boolean;
+    }) => void;
+    /**
+     * Wrap the nodes at a location in a new container node, splitting the edges
+     * of the range first to ensure that only the content in the range is wrapped.
+     */
+    wrapNodes: <T extends Node_2>(editor: Editor, element: Element_2, options?: {
+        at?: Location_2;
+        match?: NodeMatch<T>;
+        mode?: MaximizeMode;
+        split?: boolean;
+        voids?: boolean;
+    }) => void;
+}
+
+declare const NodeTransforms: NodeTransforms;
+
+export declare const normalize: EditorInterface['normalize'];
+
+/**
+ * Normalize a DOM point so that it always refers to a text node.
+ */
+export declare const normalizeDOMPoint: (domPoint: DOMPoint_2) => DOMPoint_2;
+
+export declare const normalizeNode: WithEditorFirstArg<Editor['normalizeNode']>;
+
+/**
+ * Normalize a 'pending point' a.k.a a point based on the dom state before applying
+ * the pending diffs. Since the pending diffs might have been inserted with different
+ * marks we have to 'walk' the offset from the starting position to ensure we still
+ * have a valid point inside the document
+ */
+export declare function normalizePoint(editor: Editor, point: Point): Point | null;
+
+/**
+ * Normalize a 'pending selection' to ensure it's valid in the current document state.
+ */
+export declare function normalizeRange(editor: Editor, range: Range_2): Range_2 | null;
+
+/**
+ * Remove redundant changes from the diff so that it spans the minimal possible range
+ */
+export declare function normalizeStringDiff(targetText: string, diff: StringDiff): StringDiff | null;
+
+declare type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R ? (...args: P) => R : never;
+
+export declare type Operation = ExtendedType<'Operation', BaseOperation>;
+
+export declare const Operation: OperationInterface;
+
+export declare interface OperationInterface {
+    /**
+     * Check if a value is a `NodeOperation` object.
+     */
+    isNodeOperation: (value: any) => value is NodeOperation;
+    /**
+     * Check if a value is an `Operation` object.
+     */
+    isOperation: (value: any) => value is Operation;
+    /**
+     * Check if a value is a list of `Operation` objects.
+     */
+    isOperationList: (value: any) => value is Operation[];
+    /**
+     * Check if a value is a `SelectionOperation` object.
+     */
+    isSelectionOperation: (value: any) => value is SelectionOperation;
+    /**
+     * Check if a value is a `TextOperation` object.
+     */
+    isTextOperation: (value: any) => value is TextOperation;
+    /**
+     * Invert an operation, returning a new operation that will exactly undo the
+     * original when applied.
+     */
+    inverse: (op: Operation) => Operation;
+}
+
+declare const parent_2: EditorInterface['parent'];
+export { parent_2 as parent }
+
+/**
+ * `Path` arrays are a list of indexes that describe a node's exact position in
+ * a Slate node tree. Although they are usually relative to the root `Editor`
+ * object, they can be relative to any `Node` object.
+ */
+export declare type Path = number[];
+
+export declare const Path: PathInterface;
+
+export declare const path: EditorInterface['path'];
+
+export declare interface PathAncestorsOptions {
+    reverse?: boolean;
+}
+
+export declare interface PathInterface {
+    /**
+     * Get a list of ancestor paths for a given path.
+     *
+     * The paths are sorted from shallowest to deepest ancestor. However, if the
+     * `reverse: true` option is passed, they are reversed.
+     */
+    ancestors: (path: Path, options?: PathAncestorsOptions) => Path[];
+    /**
+     * Get the common ancestor path of two paths.
+     */
+    common: (path: Path, another: Path) => Path;
+    /**
+     * Compare a path to another, returning an integer indicating whether the path
+     * was before, at, or after the other.
+     *
+     * Note: Two paths of unequal length can still receive a `0` result if one is
+     * directly above or below the other. If you want exact matching, use
+     * [[Path.equals]] instead.
+     */
+    compare: (path: Path, another: Path) => -1 | 0 | 1;
+    /**
+     * Check if a path ends after one of the indexes in another.
+     */
+    endsAfter: (path: Path, another: Path) => boolean;
+    /**
+     * Check if a path ends at one of the indexes in another.
+     */
+    endsAt: (path: Path, another: Path) => boolean;
+    /**
+     * Check if a path ends before one of the indexes in another.
+     */
+    endsBefore: (path: Path, another: Path) => boolean;
+    /**
+     * Check if a path is exactly equal to another.
+     */
+    equals: (path: Path, another: Path) => boolean;
+    /**
+     * Check if the path of previous sibling node exists
+     */
+    hasPrevious: (path: Path) => boolean;
+    /**
+     * Check if a path is after another.
+     */
+    isAfter: (path: Path, another: Path) => boolean;
+    /**
+     * Check if a path is an ancestor of another.
+     */
+    isAncestor: (path: Path, another: Path) => boolean;
+    /**
+     * Check if a path is before another.
+     */
+    isBefore: (path: Path, another: Path) => boolean;
+    /**
+     * Check if a path is a child of another.
+     */
+    isChild: (path: Path, another: Path) => boolean;
+    /**
+     * Check if a path is equal to or an ancestor of another.
+     */
+    isCommon: (path: Path, another: Path) => boolean;
+    /**
+     * Check if a path is a descendant of another.
+     */
+    isDescendant: (path: Path, another: Path) => boolean;
+    /**
+     * Check if a path is the parent of another.
+     */
+    isParent: (path: Path, another: Path) => boolean;
+    /**
+     * Check is a value implements the `Path` interface.
+     */
+    isPath: (value: any) => value is Path;
+    /**
+     * Check if a path is a sibling of another.
+     */
+    isSibling: (path: Path, another: Path) => boolean;
+    /**
+     * Get a list of paths at every level down to a path. Note: this is the same
+     * as `Path.ancestors`, but including the path itself.
+     *
+     * The paths are sorted from shallowest to deepest. However, if the `reverse:
+     * true` option is passed, they are reversed.
+     */
+    levels: (path: Path, options?: PathLevelsOptions) => Path[];
+    /**
+     * Given a path, get the path to the next sibling node.
+     */
+    next: (path: Path) => Path;
+    /**
+     * Returns whether this operation can affect paths or not. Used as an
+     * optimization when updating dirty paths during normalization
+     *
+     * NOTE: This *must* be kept in sync with the implementation of 'transform'
+     * below
+     */
+    operationCanTransformPath: (operation: Operation) => operation is InsertNodeOperation | RemoveNodeOperation | MergeNodeOperation | SplitNodeOperation | MoveNodeOperation;
+    /**
+     * Given a path, return a new path referring to the parent node above it.
+     */
+    parent: (path: Path) => Path;
+    /**
+     * Given a path, get the path to the previous sibling node.
+     */
+    previous: (path: Path) => Path;
+    /**
+     * Get a path relative to an ancestor.
+     */
+    relative: (path: Path, ancestor: Path) => Path;
+    /**
+     * Transform a path by an operation.
+     */
+    transform: (path: Path, operation: Operation, options?: PathTransformOptions) => Path | null;
+}
+
+export declare interface PathLevelsOptions {
+    reverse?: boolean;
+}
+
+/**
+ * `PathRef` objects keep a specific path in a document synced over time as new
+ * operations are applied to the editor. You can access their `current` property
+ * at any time for the up-to-date path value.
+ */
+export declare interface PathRef {
+    current: Path | null;
+    affinity: 'forward' | 'backward' | null;
+    unref(): Path | null;
+}
+
+export declare const PathRef: PathRefInterface;
+
+export declare const pathRef: EditorInterface['pathRef'];
+
+export declare interface PathRefInterface {
+    /**
+     * Transform the path ref's current value by an operation.
+     */
+    transform: (ref: PathRef, op: Operation) => void;
+}
+
+export declare const pathRefs: EditorInterface['pathRefs'];
+
+export declare interface PathTransformOptions {
+    affinity?: TextDirection | null;
+}
+
+/**
+ * Symbols.
+ */
+export declare const PLACEHOLDER_SYMBOL: string;
+
+export declare type Point = ExtendedType<'Point', BasePoint>;
+
+export declare const Point: PointInterface;
+
+export declare const point: EditorInterface['point'];
+
+/**
+ * `PointEntry` objects are returned when iterating over `Point` objects that
+ * belong to a range.
+ */
+export declare type PointEntry = [Point, 'anchor' | 'focus'];
+
+export declare interface PointInterface {
+    /**
+     * Compare a point to another, returning an integer indicating whether the
+     * point was before, at, or after the other.
+     */
+    compare: (point: Point, another: Point) => -1 | 0 | 1;
+    /**
+     * Check if a point is after another.
+     */
+    isAfter: (point: Point, another: Point) => boolean;
+    /**
+     * Check if a point is before another.
+     */
+    isBefore: (point: Point, another: Point) => boolean;
+    /**
+     * Check if a point is exactly equal to another.
+     */
+    equals: (point: Point, another: Point) => boolean;
+    /**
+     * Check if a value implements the `Point` interface.
+     */
+    isPoint: (value: any) => value is Point;
+    /**
+     * Transform a point by an operation.
+     */
+    transform: (point: Point, op: Operation, options?: PointTransformOptions) => Point | null;
+}
+
+/**
+ * `PointRef` objects keep a specific point in a document synced over time as new
+ * operations are applied to the editor. You can access their `current` property
+ * at any time for the up-to-date point value.
+ */
+export declare interface PointRef {
+    current: Point | null;
+    affinity: TextDirection | null;
+    unref(): Point | null;
+}
+
+export declare const PointRef: PointRefInterface;
+
+export declare const pointRef: EditorInterface['pointRef'];
+
+export declare interface PointRefInterface {
+    /**
+     * Transform the point ref's current value by an operation.
+     */
+    transform: (ref: PointRef, op: Operation) => void;
+}
+
+export declare const pointRefs: EditorInterface['pointRefs'];
+
+export declare interface PointTransformOptions {
+    affinity?: TextDirection | null;
+}
+
+export declare function positions(editor: Editor, options?: EditorPositionsOptions): Generator<Point, void, undefined>;
+
+export declare const previous: EditorInterface['previous'];
+
+export declare type PropsCompare = (prop: Partial<Node_2>, node: Partial<Node_2>) => boolean;
+
+export declare type PropsMerge = (prop: Partial<Node_2>, node: Partial<Node_2>) => object;
+
+export declare const range: EditorInterface['range'];
+
+declare type Range_2 = ExtendedType<'Range', BaseRange>;
+
+declare const Range_2: RangeInterface;
+export { Range_2 as Range }
+
+export declare type RangeDirection = TextDirection | 'outward' | 'inward';
+
+export declare interface RangeEdgesOptions {
+    reverse?: boolean;
+}
+
+export declare interface RangeInterface {
+    /**
+     * Get the start and end points of a range, in the order in which they appear
+     * in the document.
+     */
+    edges: (range: Range_2, options?: RangeEdgesOptions) => [Point, Point];
+    /**
+     * Get the end point of a range.
+     */
+    end: (range: Range_2) => Point;
+    /**
+     * Check if a range is exactly equal to another.
+     */
+    equals: (range: Range_2, another: Range_2) => boolean;
+    /**
+     * Check if a range includes a path, a point or part of another range.
+     */
+    includes: (range: Range_2, target: Path | Point | Range_2) => boolean;
+    /**
+     * Check if a range includes another range.
+     */
+    surrounds: (range: Range_2, target: Range_2) => boolean;
+    /**
+     * Get the intersection of a range with another.
+     */
+    intersection: (range: Range_2, another: Range_2) => Range_2 | null;
+    /**
+     * Check if a range is backward, meaning that its anchor point appears in the
+     * document _after_ its focus point.
+     */
+    isBackward: (range: Range_2) => boolean;
+    /**
+     * Check if a range is collapsed, meaning that both its anchor and focus
+     * points refer to the exact same position in the document.
+     */
+    isCollapsed: (range: Range_2) => boolean;
+    /**
+     * Check if a range is expanded.
+     *
+     * This is the opposite of [[Range.isCollapsed]] and is provided for legibility.
+     */
+    isExpanded: (range: Range_2) => boolean;
+    /**
+     * Check if a range is forward.
+     *
+     * This is the opposite of [[Range.isBackward]] and is provided for legibility.
+     */
+    isForward: (range: Range_2) => boolean;
+    /**
+     * Check if a value implements the [[Range]] interface.
+     */
+    isRange: (value: any) => value is Range_2;
+    /**
+     * Iterate through all of the point entries in a range.
+     */
+    points: (range: Range_2) => Generator<PointEntry, void, undefined>;
+    /**
+     * Get the start point of a range.
+     */
+    start: (range: Range_2) => Point;
+    /**
+     * Transform a range by an operation.
+     */
+    transform: (range: Range_2, op: Operation, options?: RangeTransformOptions) => Range_2 | null;
+}
+
+export declare type RangeMode = 'highest' | 'lowest';
+
+/**
+ * `RangeRef` objects keep a specific range in a document synced over time as new
+ * operations are applied to the editor. You can access their `current` property
+ * at any time for the up-to-date range value.
+ */
+export declare interface RangeRef {
+    current: Range_2 | null;
+    affinity: 'forward' | 'backward' | 'outward' | 'inward' | null;
+    unref(): Range_2 | null;
+}
+
+export declare const RangeRef: RangeRefInterface;
+
+export declare const rangeRef: EditorInterface['rangeRef'];
+
+export declare interface RangeRefInterface {
+    /**
+     * Transform the range ref's current value by an operation.
+     */
+    transform: (ref: RangeRef, op: Operation) => void;
+}
+
+export declare const rangeRefs: EditorInterface['rangeRefs'];
+
+export declare interface RangeTransformOptions {
+    affinity?: RangeDirection | null;
+}
+
+export declare const removeMark: EditorInterface['removeMark'];
+
+export declare type RemoveNodeOperation = ExtendedType<'RemoveNodeOperation', BaseRemoveNodeOperation>;
+
+export declare const removeNodes: NodeTransforms['removeNodes'];
+
+export declare type RemoveTextOperation = ExtendedType<'RemoveTextOperation', BaseRemoveTextOperation>;
+
+/**
+ * `RenderElementProps` are passed to the `renderElement` handler.
+ */
+export declare interface RenderElementProps {
+    children: VNode;
+    element: Element_2;
+    attributes: HTMLAttributes & {
+        "data-slate-node": "element";
+        "data-slate-inline"?: true;
+        "data-slate-void"?: true;
+        dir?: "rtl";
+        ref: any;
+    };
+}
+
+/**
+ * `RenderLeafProps` are passed to the `renderLeaf` handler.
+ */
+export declare interface RenderLeafProps {
+    children: VNode;
+    leaf: Text_2;
+    text: Text_2;
+    attributes: HTMLAttributes & {
+        "data-slate-leaf": true;
+    };
+}
+
+/**
+ * The props that get passed to renderPlaceholder
+ */
+export declare interface RenderPlaceholderProps {
+    children?: string;
+    attributes: {
+        "data-slate-placeholder": boolean;
+        dir?: "rtl";
+        contentEditable: boolean;
+        ref: VNodeRef;
+        style: CSSProperties;
+    };
+}
+
+export declare type Scrubber = (key: string, value: unknown) => unknown;
+
+/**
+ * This interface implements a stringify() function, which is used by Slate
+ * internally when generating exceptions containing end user data. Developers
+ * using Slate may call Scrubber.setScrubber() to alter the behavior of this
+ * stringify() function.
+ *
+ * For example, to prevent the cleartext logging of 'text' fields within Nodes:
+ *
+ *    import { Scrubber } from 'slate';
+ *    Scrubber.setScrubber((key, val) => {
+ *      if (key === 'text') return '...scrubbed...'
+ *      return val
+ *    });
+ *
+ */
+export declare const Scrubber: ScrubberInterface;
+
+export declare interface ScrubberInterface {
+    setScrubber(scrubber: Scrubber | undefined): void;
+    stringify(value: any): string;
+}
+
+export declare const select: SelectionTransforms['select'];
+
+declare type Selection_2 = ExtendedType<'Selection', BaseSelection>;
+export { Selection_2 as Selection }
+
+declare interface SelectionCollapseOptions {
+    edge?: SelectionEdge;
+}
+
+export declare type SelectionEdge = 'anchor' | 'focus' | 'start' | 'end';
+
+declare type SelectionMode_2 = 'all' | 'highest' | 'lowest';
+export { SelectionMode_2 as SelectionMode }
+
+declare interface SelectionMoveOptions {
+    distance?: number;
+    unit?: MoveUnit;
+    reverse?: boolean;
+    edge?: SelectionEdge;
+}
+
+export declare type SelectionOperation = SetSelectionOperation;
+
+declare interface SelectionSetPointOptions {
+    edge?: SelectionEdge;
+}
+
+declare interface SelectionTransforms {
+    /**
+     * Collapse the selection.
+     */
+    collapse: (editor: Editor, options?: SelectionCollapseOptions) => void;
+    /**
+     * Unset the selection.
+     */
+    deselect: (editor: Editor) => void;
+    /**
+     * Move the selection's point forward or backward.
+     */
+    move: (editor: Editor, options?: SelectionMoveOptions) => void;
+    /**
+     * Set the selection to a new value.
+     */
+    select: (editor: Editor, target: Location_2) => void;
+    /**
+     * Set new properties on one of the selection's points.
+     */
+    setPoint: (editor: Editor, props: Partial<Point>, options?: SelectionSetPointOptions) => void;
+    /**
+     * Set new properties on the selection.
+     */
+    setSelection: (editor: Editor, props: Partial<Range_2>) => void;
+}
+
+declare const SelectionTransforms: SelectionTransforms;
+
+export declare type SetNodeOperation = ExtendedType<'SetNodeOperation', BaseSetNodeOperation>;
+
+export declare const setNodes: NodeTransforms['setNodes'];
+
+export declare const setNormalizing: EditorInterface['setNormalizing'];
+
+export declare const setPoint: SelectionTransforms['setPoint'];
+
+export declare const setSelection: SelectionTransforms['setSelection'];
+
+export declare type SetSelectionOperation = ExtendedType<'SetSelectionOperation', BaseSetSelectionOperation>;
+
+export declare const shouldMergeNodesRemovePrevNode: EditorInterface['shouldMergeNodesRemovePrevNode'];
+
+export declare const shouldNormalize: WithEditorFirstArg<Editor['shouldNormalize']>;
+
+export declare const Slate: DefineComponent<    {
+editor: DOMEditor;
+decorate: (entry: NodeEntry) => DecoratedRange[];
+renderElement: (props: RenderElementProps) => VNode;
+renderLeaf: (props: RenderLeafProps) => VNode;
+renderPlaceholder: (props: RenderPlaceholderProps) => JSX.Element;
+}, () => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
+editor: DOMEditor;
+decorate: (entry: NodeEntry) => DecoratedRange[];
+renderElement: (props: RenderElementProps) => VNode;
+renderLeaf: (props: RenderLeafProps) => VNode;
+renderPlaceholder: (props: RenderPlaceholderProps) => JSX.Element;
+}> & Readonly<{}>, {
+decorate: Function;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+/**
+ * The `Span` interface is a low-level way to refer to locations in nodes
+ * without using `Point` which requires leaf text nodes to be present.
+ */
+export declare type Span = [Path, Path];
+
+export declare const Span: SpanInterface;
+
+export declare interface SpanInterface {
+    /**
+     * Check if a value implements the `Span` interface.
+     */
+    isSpan: (value: any) => value is Span;
+}
+
+export declare type SplitNodeOperation = ExtendedType<'SplitNodeOperation', BaseSplitNodeOperation>;
+
+export declare const splitNodes: NodeTransforms['splitNodes'];
+
+export declare const start: EditorInterface['start'];
+
+export declare const string: EditorInterface['string'];
+
+export declare type StringDiff = {
+    start: number;
+    end: number;
+    text: string;
+};
+
+/**
+ * Get the slate range the text diff spans.
+ */
+export declare function targetRange(textDiff: TextDiff): Range_2;
+
+declare type Text_2 = ExtendedType<'Text', BaseText>;
+
+declare const Text_2: TextInterface;
+export { Text_2 as Text }
+
+declare interface TextDeleteOptions {
+    at?: Location_2;
+    distance?: number;
+    unit?: TextUnit;
+    reverse?: boolean;
+    hanging?: boolean;
+    voids?: boolean;
+}
+
+export declare type TextDiff = {
+    id: number;
+    path: Path;
+    diff: StringDiff;
+};
+
+export declare type TextDirection = 'forward' | 'backward';
+
+export declare interface TextEqualsOptions {
+    loose?: boolean;
+}
+
+declare interface TextInsertFragmentOptions {
+    at?: Location_2;
+    hanging?: boolean;
+    voids?: boolean;
+    batchDirty?: boolean;
+}
+
+declare interface TextInsertTextOptions {
+    at?: Location_2;
+    voids?: boolean;
+}
+
+export declare interface TextInterface {
+    /**
+     * Check if two text nodes are equal.
+     *
+     * When loose is set, the text is not compared. This is
+     * used to check whether sibling text nodes can be merged.
+     */
+    equals: (text: Text_2, another: Text_2, options?: TextEqualsOptions) => boolean;
+    /**
+     * Check if a value implements the `Text` interface.
+     */
+    isText: (value: any) => value is Text_2;
+    /**
+     * Check if a value is a list of `Text` objects.
+     */
+    isTextList: (value: any) => value is Text_2[];
+    /**
+     * Check if some props are a partial of Text.
+     */
+    isTextProps: (props: any) => props is Partial<Text_2>;
+    /**
+     * Check if an text matches set of properties.
+     *
+     * Note: this is for matching custom properties, and it does not ensure that
+     * the `text` property are two nodes equal.
+     */
+    matches: (text: Text_2, props: Partial<Text_2>) => boolean;
+    /**
+     * Get the leaves for a text node given decorations.
+     */
+    decorations: (node: Text_2, decorations: DecoratedRange[]) => Text_2[];
+}
+
+export declare type TextOperation = InsertTextOperation | RemoveTextOperation;
+
+declare interface TextTransforms {
+    /**
+     * Delete content in the editor.
+     */
+    delete: (editor: Editor, options?: TextDeleteOptions) => void;
+    /**
+     * Insert a fragment in the editor
+     * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
+     */
+    insertFragment: (editor: Editor, fragment: Node_2[], options?: TextInsertFragmentOptions) => void;
+    /**
+     * Insert a string of text in the editor
+     * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
+     */
+    insertText: (editor: Editor, text: string, options?: TextInsertTextOptions) => void;
+}
+
+declare const TextTransforms: TextTransforms;
+
+export declare type TextUnit = 'character' | 'word' | 'line' | 'block';
+
+export declare type TextUnitAdjustment = TextUnit | 'offset';
+
+declare class toRawWeakMap<K extends WeakKey, V> {
+    private weak;
+    constructor();
+    /**
+     * Removes the specified element from the toRawWeakMap.
+     * @returns true if the element was successfully removed, or false if it was not present.
+     */
+    delete(key: K): boolean;
+    /**
+     * @returns a specified element.
+     */
+    get(key: K): V | undefined;
+    /**
+     * @returns a boolean indicating whether an element with the specified key exists or not.
+     */
+    has(key: K): boolean;
+    /**
+     * Adds a new element with a specified key and value.
+     * @param key Must be an object or symbol.
+     */
+    set(key: K, value: V): WeakMap<K, V>;
+}
+
+export declare const Transforms: GeneralTransforms & NodeTransforms & SelectionTransforms & TextTransforms;
+
+export declare const TRIPLE_CLICK = 3;
+
+export declare const unhangRange: EditorInterface['unhangRange'];
+
+export declare const unsetNodes: NodeTransforms['unsetNodes'];
+
+export declare const unwrapNodes: NodeTransforms['unwrapNodes'];
+
+/**
+ * Get the current `composing` state of the editor.
+ */
+export declare const useComposing: () => Ref<boolean, boolean>;
+
+/**
+ * Get the current editor object from the React context.
+ */
+export declare const useEditor: () => DOMEditor;
+
+/**
+ * Get the current `focused` state of the editor.
+ */
+export declare const useFocused: () => Ref<boolean, boolean>;
+
+/**
+ * Get the current `readOnly` state of the editor.
+ */
+export declare const useReadOnly: () => Ref<boolean, boolean>;
+
+/**
+ * Get the current `selected` state of an element.
+ */
+export declare const useSelected: () => ComputedRef<boolean>;
+
+/**
+ * Get the current slate selection.
+ * Only triggers a rerender when the selection actually changes
+ */
+export declare const useSelection: () => ComputedRef<BaseSelection>;
+
+/**
+ * Check whether a text diff was applied in a way we can perform the pending action on /
+ * recover the pending selection.
+ */
+export declare function verifyDiffState(editor: Editor, textDiff: TextDiff): boolean;
+
+/**
+ * `withDOM` adds DOM specific behaviors to the editor.
+ *
+ * If you are using TypeScript, you must extend Slate's CustomTypes to use
+ * this plugin.
+ *
+ * See https://docs.slatejs.org/concepts/11-typescript to learn how.
+ */
+export declare const withDOM: <T extends BaseEditor>(editor: T, clipboardFormatKey?: string) => T & DOMEditor;
+
+declare type WithEditorFirstArg<T extends (...args: any) => any> = (editor: Editor, ...args: Parameters<T>) => ReturnType<T>;
+
+export declare const withoutNormalizing: EditorInterface['withoutNormalizing'];
+
+export declare const wrapNodes: NodeTransforms['wrapNodes'];
+
+export { }
+
+
+declare global {
+    interface Window {
+        Selection: (typeof Selection)['constructor'];
+        DataTransfer: (typeof DataTransfer)['constructor'];
+        Node: (typeof Node)['constructor'];
+    }
+}
+
+
+declare module 'slate' {
+    interface CustomTypes {
+        Editor: DOMEditor;
+        Text: BaseText & {
+            placeholder?: string;
+            onPlaceholderResize?: (node: HTMLElement | null) => void;
+            [key: string]: unknown;
+        };
+        Range: BaseRange & {
+            placeholder?: string;
+            onPlaceholderResize?: (node: HTMLElement | null) => void;
+            [key: string]: unknown;
+        };
+    }
+}
+
+
+declare global {
+    interface Window {
+        MSStream: boolean;
+    }
+    interface DocumentOrShadowRoot {
+        getSelection(): Selection | null;
+    }
+    interface CaretPosition {
+        readonly offsetNode: Node;
+        readonly offset: number;
+        getClientRect(): DOMRect | null;
+    }
+    interface Document {
+        caretPositionFromPoint(x: number, y: number): CaretPosition | null;
+    }
+    interface Node {
+        getRootNode(options?: GetRootNodeOptions): Document | ShadowRoot;
+    }
+}
+
+
+declare module 'slate' {
+    interface CustomTypes {
+        Editor: DOMEditor;
+        Text: BaseText & {
+            placeholder?: string;
+            onPlaceholderResize?: (node: HTMLElement | null) => void;
+            [key: string]: unknown;
+        };
+        Range: BaseRange & {
+            placeholder?: string;
+            onPlaceholderResize?: (node: HTMLElement | null) => void;
+            [key: string]: unknown;
+        };
+    }
+}
+
+
+declare global {
+    interface Window {
+        MSStream: boolean;
+    }
+    interface DocumentOrShadowRoot {
+        getSelection(): Selection | null;
+    }
+    interface CaretPosition {
+        readonly offsetNode: Node;
+        readonly offset: number;
+        getClientRect(): DOMRect | null;
+    }
+    interface Document {
+        caretPositionFromPoint(x: number, y: number): CaretPosition | null;
+    }
+    interface Node {
+        getRootNode(options?: GetRootNodeOptions): Document | ShadowRoot;
+    }
+}