slate-vue3 0.0.32 → 0.0.35

package/dist/core.d.ts

@@ -0,0 +1,1821 @@
+export declare const above: EditorInterface['above'];
+
+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']>;
+
+/**
+ * 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 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 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'];
+
+export declare const edges: EditorInterface['edges'];
+
+export declare type Editor = ExtendedType<'Editor', BaseEditor>;
+
+export declare const Editor: EditorInterface;
+
+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 }
+
+/**
+ * `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;
+
+/**
+ * Get the "dirty" paths generated from an operation.
+ */
+export declare const getDirtyPaths: WithEditorFirstArg<Editor['getDirtyPaths']>;
+
+export declare const getFragment: WithEditorFirstArg<Editor['getFragment']>;
+
+export declare const getVoid: EditorInterface['void'];
+
+export declare const hasBlocks: EditorInterface['hasBlocks'];
+
+export declare const hasInlines: EditorInterface['hasInlines'];
+
+export declare const hasPath: EditorInterface['hasPath'];
+
+export declare const hasTexts: EditorInterface['hasTexts'];
+
+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 isBlock: EditorInterface['isBlock'];
+
+export declare const isEdge: EditorInterface['isEdge'];
+
+export declare const isEditor: EditorInterface['isEditor'];
+
+export declare const isEmpty: EditorInterface['isEmpty'];
+
+export declare const isEnd: EditorInterface['isEnd'];
+
+export declare const isNormalizing: EditorInterface['isNormalizing'];
+
+export declare const isStart: EditorInterface['isStart'];
+
+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 marks: EditorInterface['marks'];
+
+export declare type MaximizeMode = RangeMode | 'all';
+
+export declare type MergeNodeOperation = ExtendedType<'MergeNodeOperation', BaseMergeNodeOperation>;
+
+export declare const mergeNodes: NodeTransforms['mergeNodes'];
+
+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 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'];
+
+export declare const normalizeNode: WithEditorFirstArg<Editor['normalizeNode']>;
+
+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;
+}
+
+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>;
+
+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']>;
+
+/**
+ * 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'];
+
+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 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';
+
+export declare const Transforms: GeneralTransforms & NodeTransforms & SelectionTransforms & TextTransforms;
+
+export declare const unhangRange: EditorInterface['unhangRange'];
+
+export declare const unsetNodes: NodeTransforms['unsetNodes'];
+
+export declare const unwrapNodes: NodeTransforms['unwrapNodes'];
+
+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 {
+        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;
+    }
+}