@portabletext/editor 6.3.1 → 6.3.2

package/lib/_chunks-dts/behavior.types.action.d.ts

@@ -106,41 +106,10 @@ type ChildPath = [{
 }, 'children', {
   _key: string;
 }];
-type LeafEdge = 'start' | 'end';
-type MaximizeMode = RangeMode | 'all';
-type MoveUnit = 'offset' | 'character' | 'word' | 'line';
-type RangeDirection = TextDirection | 'outward' | 'inward';
-type RangeMode = 'highest' | 'lowest';
-type SelectionEdge = 'anchor' | 'focus' | 'start' | 'end';
-type SelectionMode = 'all' | 'highest' | 'lowest';
-type TextDirection = 'forward' | 'backward';
-type TextUnit = 'character' | 'word' | 'line' | 'block';
-type TextUnitAdjustment = TextUnit | 'offset';
-type OmitFirstArg<F> = F extends ((x: any, ...args: infer P) => infer R) ? (...args: P) => R : never;
-interface TextDeleteOptions {
-  at?: Location;
-  distance?: number;
-  unit?: TextUnit;
-  reverse?: boolean;
-  hanging?: boolean;
-  voids?: boolean;
-}
-interface TextInsertTextOptions {
-  at?: Location;
-  voids?: boolean;
-}
-interface TextTransforms {
-  /**
-   * Delete content in the editor.
-   */
-  delete: (editor: Editor$1, options?: TextDeleteOptions) => 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$1, text: string, options?: TextInsertTextOptions) => void;
-}
-declare const TextTransforms: TextTransforms;
+/**
+ * @public
+ */
+type EditorSchema = Schema;
 /**
  * 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.
@@ -155,11 +124,14 @@ interface BaseEditor {
   flushing: boolean;
   normalizing: boolean;
   batchingDirtyPaths: boolean;
+  pathRefs: Set<PathRef>;
+  pointRefs: Set<PointRef>;
+  rangeRefs: Set<RangeRef>;
   apply: (operation: Operation) => void;
   createSpan: () => Text$1;
   getDirtyPaths: (operation: Operation) => Path$1[];
-  getFragment: () => Descendant[];
   isElementReadOnly: (element: Element$1) => boolean;
+  isInline: (element: Element$1) => boolean;
   isSelectable: (element: Element$1) => boolean;
   normalizeNode: (entry: NodeEntry, options?: {
     operation?: Operation;
@@ -177,357 +149,19 @@ interface BaseEditor {
     dirtyPaths: Path$1[];
     operation?: Operation;
   }) => boolean;
-  collapse: OmitFirstArg<typeof Transforms.collapse>;
-  delete: OmitFirstArg<typeof Transforms.delete>;
-  deselect: OmitFirstArg<typeof Transforms.deselect>;
-  insertBreak: OmitFirstArg<typeof Editor$1.insertBreak>;
-  insertNodes: OmitFirstArg<typeof Transforms.insertNodes>;
-  insertText: OmitFirstArg<typeof Transforms.insertText>;
-  move: OmitFirstArg<typeof Transforms.move>;
-  normalize: OmitFirstArg<typeof Editor$1.normalize>;
-  removeNodes: OmitFirstArg<typeof Transforms.removeNodes>;
-  select: OmitFirstArg<typeof Transforms.select>;
-  setNormalizing: OmitFirstArg<typeof Editor$1.setNormalizing>;
-  setSelection: OmitFirstArg<typeof Transforms.setSelection>;
-  withoutNormalizing: OmitFirstArg<typeof Editor$1.withoutNormalizing>;
-  above: <T extends Ancestor>(options?: EditorAboveOptions<T>) => NodeEntry<T> | undefined;
-  after: OmitFirstArg<typeof Editor$1.after>;
-  before: OmitFirstArg<typeof Editor$1.before>;
-  elementReadOnly: OmitFirstArg<typeof Editor$1.elementReadOnly>;
-  end: OmitFirstArg<typeof Editor$1.end>;
-  hasInlines: OmitFirstArg<typeof Editor$1.hasInlines>;
-  hasPath: OmitFirstArg<typeof Editor$1.hasPath>;
-  isBlock: OmitFirstArg<typeof Editor$1.isBlock>;
-  isEdge: OmitFirstArg<typeof Editor$1.isEdge>;
-  isEnd: OmitFirstArg<typeof Editor$1.isEnd>;
-  isInline: OmitFirstArg<typeof Editor$1.isInline>;
-  isNormalizing: OmitFirstArg<typeof Editor$1.isNormalizing>;
-  isStart: OmitFirstArg<typeof Editor$1.isStart>;
-  leaf: OmitFirstArg<typeof Editor$1.leaf>;
-  levels: <T extends Node$1>(options?: EditorLevelsOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
-  next: <T extends Descendant>(options?: EditorNextOptions<T>) => NodeEntry<T> | undefined;
-  node: OmitFirstArg<typeof Editor$1.node>;
-  nodes: <T extends Node$1>(options?: EditorNodesOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
-  parent: OmitFirstArg<typeof Editor$1.parent>;
-  path: OmitFirstArg<typeof Editor$1.path>;
-  pathRef: OmitFirstArg<typeof Editor$1.pathRef>;
-  pathRefs: Set<PathRef>;
-  point: OmitFirstArg<typeof Editor$1.point>;
-  pointRef: OmitFirstArg<typeof Editor$1.pointRef>;
-  pointRefs: Set<PointRef>;
-  positions: OmitFirstArg<typeof Editor$1.positions>;
-  previous: <T extends Node$1>(options?: EditorPreviousOptions<T>) => NodeEntry<T> | undefined;
-  range: OmitFirstArg<typeof Editor$1.range>;
-  rangeRef: OmitFirstArg<typeof Editor$1.rangeRef>;
-  rangeRefs: Set<RangeRef>;
-  start: OmitFirstArg<typeof Editor$1.start>;
-  string: OmitFirstArg<typeof Editor$1.string>;
-  unhangRange: OmitFirstArg<typeof Editor$1.unhangRange>;
-  void: OmitFirstArg<typeof Editor$1.void>;
-  shouldMergeNodesRemovePrevNode: OmitFirstArg<typeof Editor$1.shouldMergeNodesRemovePrevNode>;
+  select: (target: Location) => void;
+  setSelection: (props: Partial<Range>) => void;
 }
 type Editor$1 = ExtendedType<'Editor', BaseEditor>;
 type BaseSelection = Range | null;
 type Selection$1 = ExtendedType<'Selection', BaseSelection>;
 type EditorMarks = Omit<Text$1, 'text'>;
-interface EditorAboveOptions<T extends Ancestor> {
-  at?: Location;
-  match?: NodeMatch<T>;
-  mode?: MaximizeMode;
-  voids?: boolean;
-}
-interface EditorAfterOptions {
-  distance?: number;
-  unit?: TextUnitAdjustment;
-  voids?: boolean;
-}
-interface EditorBeforeOptions {
-  distance?: number;
-  unit?: TextUnitAdjustment;
-  voids?: boolean;
-}
-interface EditorElementReadOnlyOptions {
-  at?: Location;
-  mode?: MaximizeMode;
-  voids?: boolean;
-}
-interface EditorLeafOptions {
-  depth?: number;
-  edge?: LeafEdge;
-}
-interface EditorLevelsOptions<T extends Node$1> {
-  at?: Location;
-  match?: NodeMatch<T>;
-  reverse?: boolean;
-  voids?: boolean;
-}
-interface EditorNextOptions<T extends Descendant> {
-  at?: Location;
-  match?: NodeMatch<T>;
-  mode?: SelectionMode;
-  voids?: boolean;
-}
-interface EditorNodeOptions {
-  depth?: number;
-  edge?: LeafEdge;
-}
-interface EditorNodesOptions<T extends Node$1> {
-  at?: Location | Span;
-  match?: NodeMatch<T>;
-  mode?: SelectionMode;
-  universal?: boolean;
-  reverse?: boolean;
-  voids?: boolean;
-  pass?: (entry: NodeEntry) => boolean;
-}
-interface EditorNormalizeOptions {
-  force?: boolean;
-  operation?: Operation;
-}
-interface EditorParentOptions {
-  depth?: number;
-  edge?: LeafEdge;
-}
-interface EditorPathOptions {
-  depth?: number;
-  edge?: LeafEdge;
-}
-interface EditorPathRefOptions {
-  affinity?: TextDirection | null;
-}
-interface EditorPointOptions {
-  edge?: LeafEdge;
-}
-interface EditorPointRefOptions {
-  affinity?: TextDirection | null;
-}
-interface EditorPositionsOptions {
-  at?: Location;
-  unit?: TextUnitAdjustment;
-  reverse?: boolean;
-  voids?: boolean;
-}
-interface EditorPreviousOptions<T extends Node$1> {
-  at?: Location;
-  match?: NodeMatch<T>;
-  mode?: SelectionMode;
-  voids?: boolean;
-}
-interface EditorRangeRefOptions {
-  affinity?: RangeDirection | null;
-}
-interface EditorStringOptions {
-  voids?: boolean;
-}
-interface EditorUnhangRangeOptions {
-  voids?: boolean;
-}
-interface EditorVoidOptions {
-  at?: Location;
-  mode?: MaximizeMode;
-  voids?: boolean;
-}
 interface EditorInterface {
-  /**
-   * Get the ancestor above a location in the document.
-   */
-  above: <T extends Ancestor>(editor: Editor$1, options?: EditorAboveOptions<T>) => NodeEntry<T> | undefined;
-  /**
-   * Get the point after a location.
-   */
-  after: (editor: Editor$1, at: Location, options?: EditorAfterOptions) => Point | undefined;
-  /**
-   * Get the point before a location.
-   */
-  before: (editor: Editor$1, at: Location, options?: EditorBeforeOptions) => Point | undefined;
-  /**
-   * Match a read-only element in the current branch of the editor.
-   */
-  elementReadOnly: (editor: Editor$1, options?: EditorElementReadOnlyOptions) => NodeEntry<Element$1> | undefined;
-  /**
-   * Get the end point of a location.
-   */
-  end: (editor: Editor$1, at: Location) => Point;
-  /**
-   * Check if a node has inline and text children.
-   */
-  hasInlines: (editor: Editor$1, element: Element$1) => boolean;
-  hasPath: (editor: Editor$1, path: Path$1) => boolean;
-  /**
-   * Insert a block break at the current selection.
-   *
-   * If the selection is currently expanded, it will be deleted first.
-   */
-  insertBreak: (editor: Editor$1) => 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$1, text: string, options?: TextInsertTextOptions) => void;
-  /**
-   * Check if a value is a block `Element` object.
-   */
-  isBlock: (editor: Editor$1, value: Element$1) => boolean;
-  /**
-   * Check if a point is an edge of a location.
-   */
-  isEdge: (editor: Editor$1, point: Point, at: Location) => boolean;
-  /**
-   * Check if a value is an `Editor` object.
-   */
-  isEditor: (value: any) => value is Editor$1;
-  /**
-   * Check if a value is a read-only `Element` object.
-   */
   isElementReadOnly: (editor: Editor$1, element: Element$1) => boolean;
-  /**
-   * Check if a point is the end point of a location.
-   */
-  isEnd: (editor: Editor$1, point: Point, at: Location) => boolean;
-  /**
-   * Check if a value is an inline `Element` object.
-   */
   isInline: (editor: Editor$1, value: Element$1) => boolean;
-  /**
-   * Check if the editor is currently normalizing after each operation.
-   */
-  isNormalizing: (editor: Editor$1) => boolean;
-  /**
-   * Check if a value is a selectable `Element` object.
-   */
   isSelectable: (editor: Editor$1, element: Element$1) => boolean;
-  /**
-   * Check if a point is the start point of a location.
-   */
-  isStart: (editor: Editor$1, point: Point, at: Location) => boolean;
-  /**
-   * Get the leaf text node at a location.
-   */
-  leaf: (editor: Editor$1, at: Location, options?: EditorLeafOptions) => NodeEntry<Text$1 | ObjectNode>;
-  /**
-   * Iterate through all of the levels at a location.
-   */
-  levels: <T extends Node$1>(editor: Editor$1, options?: EditorLevelsOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
-  /**
-   * Get the matching node in the branch of the document after a location.
-   */
-  next: <T extends Descendant>(editor: Editor$1, options?: EditorNextOptions<T>) => NodeEntry<T> | undefined;
-  /**
-   * Get the node at a location.
-   */
-  node: (editor: Editor$1, at: Location, options?: EditorNodeOptions) => NodeEntry;
-  /**
-   * Iterate through all of the nodes in the Editor.
-   */
-  nodes: <T extends Node$1>(editor: Editor$1, options?: EditorNodesOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
-  /**
-   * Normalize any dirty objects in the editor.
-   */
-  normalize: (editor: Editor$1, options?: EditorNormalizeOptions) => void;
-  /**
-   * Get the parent node of a location.
-   */
-  parent: (editor: Editor$1, at: Location, options?: EditorParentOptions) => NodeEntry<Ancestor>;
-  /**
-   * Get the path of a location.
-   */
-  path: (editor: Editor$1, at: Location, options?: EditorPathOptions) => Path$1;
-  /**
-   * Create a mutable ref for a `Path` object, which will stay in sync as new
-   * operations are applied to the editor.
-   */
-  pathRef: (editor: Editor$1, path: Path$1, options?: EditorPathRefOptions) => PathRef;
-  /**
-   * Get the set of currently tracked path refs of the editor.
-   */
-  pathRefs: (editor: Editor$1) => Set<PathRef>;
-  /**
-   * Get the start or end point of a location.
-   */
-  point: (editor: Editor$1, at: Location, 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$1, point: Point, options?: EditorPointRefOptions) => PointRef;
-  /**
-   * Get the set of currently tracked point refs of the editor.
-   */
-  pointRefs: (editor: Editor$1) => 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$1, options?: EditorPositionsOptions) => Generator<Point, void, undefined>;
-  /**
-   * Get the matching node in the branch of the document before a location.
-   */
-  previous: <T extends Node$1>(editor: Editor$1, options?: EditorPreviousOptions<T>) => NodeEntry<T> | undefined;
-  /**
-   * Get a range of a location.
-   */
-  range: (editor: Editor$1, at: Location, to?: Location) => Range;
-  /**
-   * Create a mutable ref for a `Range` object, which will stay in sync as new
-   * operations are applied to the editor.
-   */
-  rangeRef: (editor: Editor$1, range: Range, options?: EditorRangeRefOptions) => RangeRef;
-  /**
-   * Get the set of currently tracked range refs of the editor.
-   */
-  rangeRefs: (editor: Editor$1) => Set<RangeRef>;
-  /**
-   * Manually set if the editor should currently be normalizing.
-   *
-   * Note: Using this incorrectly can leave the editor in an invalid state.
-   *
-   */
-  setNormalizing: (editor: Editor$1, isNormalizing: boolean) => void;
-  /**
-   * Get the start point of a location.
-   */
-  start: (editor: Editor$1, at: Location) => 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$1, at: Location, options?: EditorStringOptions) => string;
-  /**
-   * Convert a range into a non-hanging one.
-   */
-  unhangRange: (editor: Editor$1, range: Range, options?: EditorUnhangRangeOptions) => Range;
-  /**
-   * Match a void node in the current branch of the editor.
-   */
-  void: (editor: Editor$1, options?: EditorVoidOptions) => NodeEntry<Element$1> | undefined;
-  /**
-   * Call a function, deferring normalization until after it completes.
-   */
-  withoutNormalizing: (editor: Editor$1, fn: () => void) => void;
-  /**
-   *  Call a function, Determine whether or not remove the previous node when merge.
-   */
-  shouldMergeNodesRemovePrevNode: (editor: Editor$1, prevNodeEntry: NodeEntry, curNodeEntry: NodeEntry) => boolean;
 }
 declare const Editor$1: EditorInterface;
-/**
- * A helper type for narrowing matched nodes with a predicate.
- */
-type NodeMatch<T extends Node$1> = ((node: Node$1, path: Path$1) => node is T) | ((node: Node$1, path: Path$1) => boolean);
-/**
- * @public
- */
-type EditorSchema = Schema;
 /**
  * `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"
@@ -557,18 +191,6 @@ declare const Element$1: ElementInterface;
  * converting between the different interfaces in their own code base.
  */
 type Location = Path$1 | Point | Range;
-/**
- * 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.
- */
-type Span = [Path$1, Path$1];
-interface SpanInterface {
-  /**
-   * Check if a value implements the `Span` interface.
-   */
-  isSpan: (value: any) => value is Span;
-}
-declare const Span: SpanInterface;
 /**
  * Extendable Custom Types Interface
  */
@@ -588,120 +210,6 @@ interface BaseObjectNode {
 }
 type ObjectNode = ExtendedType<'ObjectNode', BaseObjectNode>;
 type Node$1 = Editor$1 | Element$1 | ObjectNode | Text$1;
-interface NodeChildrenOptions {
-  reverse?: boolean;
-}
-interface NodeLevelsOptions {
-  reverse?: boolean;
-}
-interface NodeNodesOptions {
-  from?: Path$1;
-  to?: Path$1;
-  reverse?: boolean;
-  pass?: (entry: NodeEntry) => boolean;
-}
-interface NodeTextsOptions {
-  from?: Path$1;
-  to?: Path$1;
-  reverse?: boolean;
-  pass?: (node: NodeEntry) => boolean;
-}
-interface NodeInterface {
-  /**
-   * Get the node at a specific path, asserting that it's an ancestor node.
-   */
-  ancestor: (root: Node$1, path: Path$1, schema: EditorSchema) => Ancestor;
-  /**
-   * Get the child of a node at a specific index.
-   */
-  child: (root: Node$1, index: number, schema: EditorSchema) => Descendant;
-  /**
-   * Iterate over the children of a node at a specific path.
-   */
-  children: (root: Node$1, path: Path$1, schema: EditorSchema, options?: NodeChildrenOptions) => Generator<NodeEntry<Descendant>, void, undefined>;
-  /**
-   * Extract props from a Node.
-   */
-  extractProps: (node: Node$1, schema: EditorSchema) => NodeProps;
-  /**
-   * Get the first leaf node entry in a root node from a path.
-   */
-  first: (root: Node$1, path: Path$1, schema: EditorSchema) => NodeEntry;
-  /**
-   * Get the sliced fragment represented by a range inside a root node.
-   */
-  fragment: <T extends Ancestor = Editor$1>(root: T, range: Range, schema: EditorSchema) => T['children'];
-  /**
-   * 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$1, path: Path$1, schema: EditorSchema) => Node$1;
-  /**
-   * Similar to get, but returns undefined if the node does not exist.
-   */
-  getIf: (root: Node$1, path: Path$1, schema: EditorSchema) => Node$1 | undefined;
-  /**
-   * Check if a descendant node exists at a specific path.
-   */
-  has: (root: Node$1, path: Path$1, schema: EditorSchema) => boolean;
-  /**
-   * Check if a value implements the `Node` interface.
-   */
-  isNode: (value: any, schema: EditorSchema) => value is Node$1;
-  /**
-   * Check if a value is a list of `Node` objects.
-   */
-  isNodeList: (value: any, schema: EditorSchema) => value is Node$1[];
-  /**
-   * Check if a value is a leaf node (Text or ObjectNode).
-   * Leaf nodes have no children to descend into.
-   */
-  isLeaf: (value: any, schema: EditorSchema) => boolean;
-  /**
-   * Check if a value is an ObjectNode. Uses schema to determine whether
-   * a node's _type is neither the block type name nor the span type name.
-   */
-  isObjectNode: (value: any, schema: EditorSchema) => value is ObjectNode;
-  /**
-   * Get the last leaf node entry in a root node from a path.
-   */
-  last: (root: Node$1, path: Path$1, schema: EditorSchema) => NodeEntry;
-  /**
-   * Get the node at a specific path, ensuring it's a leaf node (Text or
-   * ObjectNode).
-   */
-  leaf: (root: Node$1, path: Path$1, schema: EditorSchema) => Text$1 | ObjectNode;
-  /**
-   * 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$1, path: Path$1, schema: EditorSchema, options?: NodeLevelsOptions) => Generator<NodeEntry, void, undefined>;
-  /**
-   * 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$1, schema: EditorSchema, options?: NodeNodesOptions) => Generator<NodeEntry, void, undefined>;
-  /**
-   * Get the parent of a node at a specific path.
-   */
-  parent: (root: Node$1, path: Path$1, schema: EditorSchema) => 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$1, schema: EditorSchema) => string;
-  /**
-   * Return a generator of all leaf text nodes in a root node.
-   */
-  texts: (root: Node$1, schema: EditorSchema, options?: NodeTextsOptions) => Generator<NodeEntry<Text$1>, void, undefined>;
-}
-declare const Node$1: NodeInterface;
 /**
  * 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
@@ -720,10 +228,6 @@ type Ancestor = Editor$1 | Element$1;
  * node in the document.
  */
 type NodeEntry<T extends Node$1 = Node$1> = [T, Path$1];
-/**
- * Convenience type for returning the props of a node.
- */
-type NodeProps = Omit<Editor$1, 'children'> | Omit<Element$1, 'children'> | ObjectNode | Omit<Text$1, 'text'>;
 type BaseInsertNodeOperation = {
   type: 'insert_node';
   path: Path$1;
@@ -919,6 +423,8 @@ interface PathInterface {
   transform: (path: Path$1, operation: Operation) => Path$1 | null;
 }
 declare const Path$1: PathInterface;
+type RangeDirection = TextDirection | 'outward' | 'inward';
+type TextDirection = 'forward' | 'backward';
 /**
  * `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
@@ -1124,73 +630,6 @@ interface TextInterface {
   }[];
 }
 declare const Text$1: TextInterface;
-interface GeneralTransforms {
-  /**
-   * Transform the editor by an operation.
-   */
-  transform: (editor: Editor$1, op: Operation) => void;
-}
-declare const GeneralTransforms: GeneralTransforms;
-interface NodeInsertNodesOptions<T extends Node$1> {
-  at?: Location;
-  match?: NodeMatch<T>;
-  mode?: RangeMode;
-  hanging?: boolean;
-  select?: boolean;
-  voids?: boolean;
-  batchDirty?: boolean;
-}
-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$1>(editor: Editor$1, nodes: Node$1 | Node$1[], options?: NodeInsertNodesOptions<T>) => void;
-  /**
-   * Remove the nodes at a specific location in the document.
-   */
-  removeNodes: <T extends Node$1>(editor: Editor$1, options?: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: RangeMode;
-    hanging?: boolean;
-    voids?: boolean;
-  }) => void;
-}
-declare const NodeTransforms: NodeTransforms;
-interface SelectionCollapseOptions {
-  edge?: SelectionEdge;
-}
-interface SelectionMoveOptions {
-  distance?: number;
-  unit?: MoveUnit;
-  reverse?: boolean;
-  edge?: SelectionEdge;
-}
-interface SelectionTransforms {
-  /**
-   * Collapse the selection.
-   */
-  collapse: (editor: Editor$1, options?: SelectionCollapseOptions) => void;
-  /**
-   * Unset the selection.
-   */
-  deselect: (editor: Editor$1) => void;
-  /**
-   * Move the selection's point forward or backward.
-   */
-  move: (editor: Editor$1, options?: SelectionMoveOptions) => void;
-  /**
-   * Set the selection to a new value.
-   */
-  select: (editor: Editor$1, target: Location) => void;
-  /**
-   * Set new properties on the selection.
-   */
-  setSelection: (editor: Editor$1, props: Partial<Range>) => void;
-}
-declare const SelectionTransforms: SelectionTransforms;
-declare const Transforms: GeneralTransforms & NodeTransforms & SelectionTransforms & TextTransforms;
 type DecoratedRange = BaseRange & {
   rangeDecoration: RangeDecoration;
 };
@@ -1242,8 +681,6 @@ interface DOMEditor extends BaseEditor {
   hasRange: (editor: Editor$1, range: Range) => boolean;
   hasSelectableTarget: (editor: Editor$1, target: EventTarget | null) => boolean;
   hasTarget: (editor: Editor$1, target: EventTarget | null) => target is DOMNode;
-  insertData: (data: DataTransfer) => void;
-  insertTextData: (data: DataTransfer) => boolean;
   isTargetInsideNonReadonlyVoid: (editor: Editor$1, target: EventTarget | null) => boolean;
   isNodeMapDirty: boolean;
   domWindow: Window | null;
@@ -1441,14 +878,6 @@ interface PortableTextSlateEditor extends ReactEditor {
   isRedoing: boolean;
   isUndoing: boolean;
   withHistory: boolean;
-  /**
-   * Undo
-   */
-  undo: () => void;
-  /**
-   * Redo
-   */
-  redo: () => void;
 }
 /**
  * @public