@portabletext/editor 6.1.0-canary.0 → 6.1.0

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

@@ -1,9 +1,9 @@
-import * as _portabletext_schema5 from "@portabletext/schema";
+import * as _portabletext_schema6 from "@portabletext/schema";
 import { AnnotationDefinition, AnnotationSchemaType, AnnotationSchemaType as AnnotationSchemaType$1, BaseDefinition, BlockObjectDefinition, BlockObjectSchemaType, BlockObjectSchemaType as BlockObjectSchemaType$1, DecoratorDefinition, DecoratorSchemaType, DecoratorSchemaType as DecoratorSchemaType$1, FieldDefinition, InlineObjectDefinition, InlineObjectSchemaType, InlineObjectSchemaType as InlineObjectSchemaType$1, ListDefinition, ListSchemaType, ListSchemaType as ListSchemaType$1, PortableTextBlock, PortableTextBlock as PortableTextBlock$1, PortableTextChild, PortableTextChild as PortableTextChild$1, PortableTextListBlock, PortableTextObject, PortableTextObject as PortableTextObject$1, PortableTextSpan, PortableTextSpan as PortableTextSpan$1, PortableTextTextBlock, PortableTextTextBlock as PortableTextTextBlock$1, Schema, SchemaDefinition, SchemaDefinition as SchemaDefinition$1, StyleDefinition, StyleSchemaType, StyleSchemaType as StyleSchemaType$1, TypedObject, defineSchema } from "@portabletext/schema";
 import * as xstate73 from "xstate";
 import { ActorRef, ActorRefFrom, EventObject, Snapshot } from "xstate";
-import * as react10 from "react";
-import React$1, { BaseSyntheticEvent, ClipboardEvent as ClipboardEvent$1, FocusEvent, JSX, PropsWithChildren, ReactElement, RefObject, TextareaHTMLAttributes } from "react";
+import * as react8 from "react";
+import React$1, { BaseSyntheticEvent, ClipboardEvent as ClipboardEvent$1, FocusEvent, JSX, MutableRefObject, PropsWithChildren, ReactElement, RefObject, TextareaHTMLAttributes } from "react";
 import { Patch, Patch as Patch$1 } from "@portabletext/patches";
 type MIMEType = `${string}/${string}`;
 /**
@@ -117,121 +117,6 @@ 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 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;
-  /**
-   * Lift nodes at a specific location upwards in the document tree, splitting
-   * their parent in two if necessary.
-   */
-  liftNodes: <T extends Node$1>(editor: Editor$1, options?: {
-    at?: Location;
-    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$1>(editor: Editor$1, options?: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: RangeMode;
-    hanging?: boolean;
-    voids?: boolean;
-  }) => void;
-  /**
-   * Move the nodes at a location to a new location.
-   */
-  moveNodes: <T extends Node$1>(editor: Editor$1, options: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: MaximizeMode;
-    to: Path$1;
-    voids?: boolean;
-  }) => 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;
-  /**
-   * Set new properties on the nodes at a location.
-   */
-  setNodes: <T extends Node$1>(editor: Editor$1, props: Partial<T>, options?: {
-    at?: Location;
-    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$1>(editor: Editor$1, options?: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: RangeMode;
-    always?: boolean;
-    height?: number;
-    voids?: boolean;
-  }) => void;
-  /**
-   * Unset properties on the nodes at a location.
-   */
-  unsetNodes: <T extends Node$1>(editor: Editor$1, props: string | string[], options?: {
-    at?: Location;
-    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$1>(editor: Editor$1, options?: {
-    at?: Location;
-    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$1>(editor: Editor$1, element: Element$1, options?: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: MaximizeMode;
-    split?: boolean;
-    voids?: boolean;
-  }) => void;
-}
-declare const NodeTransforms: NodeTransforms;
 interface TextDeleteOptions {
   at?: Location;
   distance?: number;
@@ -240,12 +125,6 @@ interface TextDeleteOptions {
   hanging?: boolean;
   voids?: boolean;
 }
-interface TextInsertFragmentOptions {
-  at?: Location;
-  hanging?: boolean;
-  voids?: boolean;
-  batchDirty?: boolean;
-}
 interface TextInsertTextOptions {
   at?: Location;
   voids?: boolean;
@@ -255,11 +134,6 @@ interface TextTransforms {
    * Delete content in the editor.
    */
   delete: (editor: Editor$1, 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$1, fragment: Node$1[], 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.
@@ -276,16 +150,19 @@ interface BaseEditor {
   selection: Selection$1;
   operations: Operation[];
   marks: EditorMarks | null;
+  dirtyPaths: Path$1[];
+  dirtyPathKeys: Set<string>;
+  flushing: boolean;
+  normalizing: boolean;
+  batchingDirtyPaths: boolean;
   apply: (operation: Operation) => void;
   createSpan: () => Text$1;
   getDirtyPaths: (operation: Operation) => Path$1[];
   getFragment: () => Descendant[];
   isElementReadOnly: (element: Element$1) => boolean;
   isSelectable: (element: Element$1) => boolean;
-  markableVoid: (element: Element$1) => boolean;
   normalizeNode: (entry: NodeEntry, options?: {
     operation?: Operation;
-    fallbackElement?: () => Element$1;
   }) => void;
   onChange: (options?: {
     operation?: Operation;
@@ -300,67 +177,36 @@ interface BaseEditor {
     dirtyPaths: Path$1[];
     operation?: Operation;
   }) => boolean;
-  addMark: OmitFirstArg<typeof Editor$1.addMark>;
   collapse: OmitFirstArg<typeof Transforms.collapse>;
   delete: OmitFirstArg<typeof Transforms.delete>;
-  deleteBackward: (unit: TextUnit) => void;
-  deleteForward: (unit: TextUnit) => void;
-  deleteFragment: OmitFirstArg<typeof Editor$1.deleteFragment>;
   deselect: OmitFirstArg<typeof Transforms.deselect>;
   insertBreak: OmitFirstArg<typeof Editor$1.insertBreak>;
-  insertFragment: OmitFirstArg<typeof Transforms.insertFragment>;
-  insertNode: OmitFirstArg<typeof Editor$1.insertNode>;
   insertNodes: OmitFirstArg<typeof Transforms.insertNodes>;
-  insertSoftBreak: OmitFirstArg<typeof Editor$1.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$1.normalize>;
-  removeMark: OmitFirstArg<typeof Editor$1.removeMark>;
   removeNodes: OmitFirstArg<typeof Transforms.removeNodes>;
   select: OmitFirstArg<typeof Transforms.select>;
-  setNodes: <T extends Node$1>(props: Partial<T>, options?: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: MaximizeMode;
-    hanging?: boolean;
-    split?: boolean;
-    voids?: boolean;
-    compare?: PropsCompare;
-    merge?: PropsMerge;
-  }) => void;
   setNormalizing: OmitFirstArg<typeof Editor$1.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$1.withoutNormalizing>;
-  wrapNodes: OmitFirstArg<typeof Transforms.wrapNodes>;
   above: <T extends Ancestor>(options?: EditorAboveOptions<T>) => NodeEntry<T> | undefined;
   after: OmitFirstArg<typeof Editor$1.after>;
   before: OmitFirstArg<typeof Editor$1.before>;
-  edges: OmitFirstArg<typeof Editor$1.edges>;
   elementReadOnly: OmitFirstArg<typeof Editor$1.elementReadOnly>;
   end: OmitFirstArg<typeof Editor$1.end>;
-  first: OmitFirstArg<typeof Editor$1.first>;
-  fragment: OmitFirstArg<typeof Editor$1.fragment>;
   getMarks: OmitFirstArg<typeof Editor$1.marks>;
-  hasBlocks: OmitFirstArg<typeof Editor$1.hasBlocks>;
   hasInlines: OmitFirstArg<typeof Editor$1.hasInlines>;
   hasPath: OmitFirstArg<typeof Editor$1.hasPath>;
-  hasTexts: OmitFirstArg<typeof Editor$1.hasTexts>;
   isBlock: OmitFirstArg<typeof Editor$1.isBlock>;
   isEdge: OmitFirstArg<typeof Editor$1.isEdge>;
-  isEmpty: OmitFirstArg<typeof Editor$1.isEmpty>;
   isEnd: OmitFirstArg<typeof Editor$1.isEnd>;
   isInline: OmitFirstArg<typeof Editor$1.isInline>;
   isNormalizing: OmitFirstArg<typeof Editor$1.isNormalizing>;
   isStart: OmitFirstArg<typeof Editor$1.isStart>;
-  isVoid: OmitFirstArg<typeof Editor$1.isVoid>;
-  last: OmitFirstArg<typeof Editor$1.last>;
   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;
@@ -369,15 +215,15 @@ interface BaseEditor {
   parent: OmitFirstArg<typeof Editor$1.parent>;
   path: OmitFirstArg<typeof Editor$1.path>;
   pathRef: OmitFirstArg<typeof Editor$1.pathRef>;
-  pathRefs: OmitFirstArg<typeof Editor$1.pathRefs>;
+  pathRefs: Set<PathRef>;
   point: OmitFirstArg<typeof Editor$1.point>;
   pointRef: OmitFirstArg<typeof Editor$1.pointRef>;
-  pointRefs: OmitFirstArg<typeof Editor$1.pointRefs>;
+  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: OmitFirstArg<typeof Editor$1.rangeRefs>;
+  rangeRefs: Set<RangeRef>;
   start: OmitFirstArg<typeof Editor$1.start>;
   string: OmitFirstArg<typeof Editor$1.string>;
   unhangRange: OmitFirstArg<typeof Editor$1.unhangRange>;
@@ -404,20 +250,11 @@ interface EditorBeforeOptions {
   unit?: TextUnitAdjustment;
   voids?: boolean;
 }
-interface EditorDirectedDeletionOptions {
-  unit?: TextUnit;
-}
 interface EditorElementReadOnlyOptions {
   at?: Location;
   mode?: MaximizeMode;
   voids?: boolean;
 }
-interface EditorFragmentDeletionOptions {
-  direction?: TextDirection;
-}
-interface EditorIsEditorOptions {
-  deep?: boolean;
-}
 interface EditorLeafOptions {
   depth?: number;
   edge?: LeafEdge;
@@ -499,13 +336,6 @@ interface EditorInterface {
    * Get the ancestor above a location in the document.
    */
   above: <T extends Ancestor>(editor: Editor$1, 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$1, key: string, value: any) => void;
   /**
    * Get the point after a location.
    */
@@ -514,22 +344,6 @@ interface EditorInterface {
    * Get the point before a location.
    */
   before: (editor: Editor$1, at: Location, options?: EditorBeforeOptions) => Point | undefined;
-  /**
-   * Delete content in the editor backward from the current selection.
-   */
-  deleteBackward: (editor: Editor$1, options?: EditorDirectedDeletionOptions) => void;
-  /**
-   * Delete content in the editor forward from the current selection.
-   */
-  deleteForward: (editor: Editor$1, options?: EditorDirectedDeletionOptions) => void;
-  /**
-   * Delete the content in the current selection.
-   */
-  deleteFragment: (editor: Editor$1, options?: EditorFragmentDeletionOptions) => void;
-  /**
-   * Get the start and end points of a location.
-   */
-  edges: (editor: Editor$1, at: Location) => [Point, Point];
   /**
    * Match a read-only element in the current branch of the editor.
    */
@@ -538,49 +352,17 @@ interface EditorInterface {
    * Get the end point of a location.
    */
   end: (editor: Editor$1, at: Location) => Point;
-  /**
-   * Get the first node at a location.
-   */
-  first: (editor: Editor$1, at: Location) => NodeEntry;
-  /**
-   * Get the fragment at a location.
-   */
-  fragment: (editor: Editor$1, at: Location) => Descendant[];
-  /**
-   * Check if a node has block children.
-   */
-  hasBlocks: (editor: Editor$1, element: Element$1) => boolean;
   /**
    * 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;
-  /**
-   * Check if a node has text children.
-   */
-  hasTexts: (editor: Editor$1, element: Element$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;
-  /**
-   * 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$1, fragment: Node$1[], 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$1>(editor: Editor$1, node: Node$1, 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$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.
@@ -597,15 +379,11 @@ interface EditorInterface {
   /**
    * Check if a value is an `Editor` object.
    */
-  isEditor: (value: any, options?: EditorIsEditorOptions) => value is Editor$1;
+  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 an element is empty, accounting for void nodes.
-   */
-  isEmpty: (editor: Editor$1, element: Element$1) => boolean;
   /**
    * Check if a point is the end point of a location.
    */
@@ -626,18 +404,10 @@ interface EditorInterface {
    * Check if a point is the start point of a location.
    */
   isStart: (editor: Editor$1, point: Point, at: Location) => boolean;
-  /**
-   * Check if a value is a void `Element` object.
-   */
-  isVoid: (editor: Editor$1, value: Element$1) => boolean;
-  /**
-   * Get the last node at a location.
-   */
-  last: (editor: Editor$1, at: Location) => NodeEntry;
   /**
    * Get the leaf text node at a location.
    */
-  leaf: (editor: Editor$1, at: Location, options?: EditorLeafOptions) => NodeEntry<Text$1>;
+  leaf: (editor: Editor$1, at: Location, options?: EditorLeafOptions) => NodeEntry<Text$1 | ObjectNode>;
   /**
    * Iterate through all of the levels at a location.
    */
@@ -722,14 +492,6 @@ interface EditorInterface {
    * Get the set of currently tracked range refs of the editor.
    */
   rangeRefs: (editor: Editor$1) => 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$1, key: string) => void;
   /**
    * Manually set if the editor should currently be normalizing.
    *
@@ -770,8 +532,10 @@ 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);
-type PropsCompare = (prop: Partial<Node$1>, node: Partial<Node$1>) => boolean;
-type PropsMerge = (prop: Partial<Node$1>, node: Partial<Node$1>) => object;
+/**
+ * @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"
@@ -781,31 +545,23 @@ interface BaseElement {
   children: Descendant[];
 }
 type Element$1 = ExtendedType<'Element', BaseElement>;
-interface ElementIsElementOptions {
-  deep?: boolean;
-}
 interface ElementInterface {
   /**
    * Check if a value implements the 'Ancestor' interface.
    */
-  isAncestor: (value: any, options?: ElementIsElementOptions) => value is Ancestor;
+  isAncestor: (value: any, schema: EditorSchema) => value is Ancestor;
   /**
    * Check if a value implements the `Element` interface.
    */
-  isElement: (value: any, options?: ElementIsElementOptions) => value is Element$1;
+  isElement: (value: any, schema: EditorSchema) => value is Element$1;
   /**
    * Check if a value is an array of `Element` objects.
    */
-  isElementList: (value: any, options?: ElementIsElementOptions) => value is Element$1[];
+  isElementList: (value: any, schema: EditorSchema) => value is Element$1[];
   /**
    * Check if a set of props is a partial of Element.
    */
   isElementProps: (props: any) => props is Partial<Element$1>;
-  /**
-   * 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$1>(value: any, elementVal: string, elementKey?: string) => value is T;
   /**
    * Check if an element matches set of properties.
    *
@@ -848,7 +604,25 @@ interface SpanInterface {
   isSpan: (value: any) => value is Span;
 }
 declare const Span: SpanInterface;
-type Node$1 = Editor$1 | Element$1 | Text$1;
+/**
+ * Extendable Custom Types Interface
+ */
+type ExtendableTypes = 'Editor' | 'Element' | 'ObjectNode' | 'Text' | 'Selection' | 'Range' | 'Point' | 'Operation' | 'InsertNodeOperation' | 'InsertTextOperation' | 'MergeNodeOperation' | 'MoveNodeOperation' | 'RemoveNodeOperation' | 'RemoveTextOperation' | 'SetNodeOperation' | 'SetSelectionOperation' | 'SplitNodeOperation';
+interface CustomTypes {
+  [key: string]: unknown;
+}
+type ExtendedType<K$1 extends ExtendableTypes, B> = unknown extends CustomTypes[K$1] ? B : CustomTypes[K$1];
+/**
+ * `ObjectNode` represents a node with semantic content but no children or text.
+ * Block objects and inline objects are ObjectNodes in the tree.
+ */
+interface BaseObjectNode {
+  _type: string;
+  _key: string;
+  [key: string]: unknown;
+}
+type ObjectNode = ExtendedType<'ObjectNode', BaseObjectNode>;
+type Node$1 = Editor$1 | Element$1 | ObjectNode | Text$1;
 interface NodeAncestorsOptions {
   reverse?: boolean;
 }
@@ -867,9 +641,6 @@ interface NodeElementsOptions {
   reverse?: boolean;
   pass?: (node: NodeEntry) => boolean;
 }
-interface NodeIsNodeOptions {
-  deep?: boolean;
-}
 interface NodeLevelsOptions {
   reverse?: boolean;
 }
@@ -889,102 +660,113 @@ interface NodeInterface {
   /**
    * Get the node at a specific path, asserting that it's an ancestor node.
    */
-  ancestor: (root: Node$1, path: Path$1) => Ancestor;
+  ancestor: (root: Node$1, path: Path$1, schema: EditorSchema) => 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$1, path: Path$1, options?: NodeAncestorsOptions) => Generator<NodeEntry<Ancestor>, void, undefined>;
+  ancestors: (root: Node$1, path: Path$1, schema: EditorSchema, options?: NodeAncestorsOptions) => Generator<NodeEntry<Ancestor>, void, undefined>;
   /**
    * Get the child of a node at a specific index.
    */
-  child: (root: Node$1, index: number) => Descendant;
+  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, options?: NodeChildrenOptions) => Generator<NodeEntry<Descendant>, void, undefined>;
+  children: (root: Node$1, path: Path$1, schema: EditorSchema, options?: NodeChildrenOptions) => Generator<NodeEntry<Descendant>, void, undefined>;
   /**
    * Get an entry for the common ancesetor node of two paths.
    */
-  common: (root: Node$1, path: Path$1, another: Path$1) => NodeEntry;
+  common: (root: Node$1, path: Path$1, another: Path$1, schema: EditorSchema) => NodeEntry;
   /**
    * Get the node at a specific path, asserting that it's a descendant node.
    */
-  descendant: (root: Node$1, path: Path$1) => Descendant;
+  descendant: (root: Node$1, path: Path$1, schema: EditorSchema) => Descendant;
   /**
    * Return a generator of all the descendant node entries inside a root node.
    */
-  descendants: (root: Node$1, options?: NodeDescendantsOptions) => Generator<NodeEntry<Descendant>, void, undefined>;
+  descendants: (root: Node$1, schema: EditorSchema, 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$1, options?: NodeElementsOptions) => Generator<ElementEntry, void, undefined>;
+  elements: (root: Node$1, schema: EditorSchema, options?: NodeElementsOptions) => Generator<ElementEntry, void, undefined>;
   /**
    * Extract props from a Node.
    */
-  extractProps: (node: Node$1) => NodeProps;
+  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) => NodeEntry;
+  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) => T['children'];
+  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) => Node$1;
+  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) => Node$1 | undefined;
+  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) => boolean;
+  has: (root: Node$1, path: Path$1, schema: EditorSchema) => boolean;
   /**
    * Check if a value implements the `Node` interface.
    */
-  isNode: (value: any, options?: NodeIsNodeOptions) => value is Node$1;
+  isNode: (value: any, schema: EditorSchema) => value is Node$1;
   /**
    * Check if a value is a list of `Node` objects.
    */
-  isNodeList: (value: any, options?: NodeIsNodeOptions) => value is Node$1[];
+  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) => NodeEntry;
+  last: (root: Node$1, path: Path$1, schema: EditorSchema) => NodeEntry;
   /**
-   * Get the node at a specific path, ensuring it's a leaf text node.
+   * Get the node at a specific path, ensuring it's a leaf node (Text or
+   * ObjectNode).
    */
-  leaf: (root: Node$1, path: Path$1) => Text$1;
+  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, options?: NodeLevelsOptions) => Generator<NodeEntry, void, undefined>;
+  levels: (root: Node$1, path: Path$1, schema: EditorSchema, options?: NodeLevelsOptions) => Generator<NodeEntry, void, undefined>;
   /**
    * Check if a node matches a set of props.
    */
-  matches: (node: Node$1, props: Partial<Node$1>) => boolean;
+  matches: (node: Node$1, props: Partial<Node$1>, schema: EditorSchema) => 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$1, options?: NodeNodesOptions) => Generator<NodeEntry, void, undefined>;
+  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) => Ancestor;
+  parent: (root: Node$1, path: Path$1, schema: EditorSchema) => Ancestor;
   /**
    * Get the concatenated text string of a node's content.
    *
@@ -992,11 +774,11 @@ interface NodeInterface {
    * It is not a user-facing string, but a string for performing offset-related
    * computations for a node.
    */
-  string: (node: Node$1) => string;
+  string: (node: Node$1, schema: EditorSchema) => string;
   /**
    * Return a generator of all leaf text nodes in a root node.
    */
-  texts: (root: Node$1, options?: NodeTextsOptions) => Generator<NodeEntry<Text$1>, void, undefined>;
+  texts: (root: Node$1, schema: EditorSchema, options?: NodeTextsOptions) => Generator<NodeEntry<Text$1>, void, undefined>;
 }
 declare const Node$1: NodeInterface;
 /**
@@ -1004,7 +786,7 @@ declare const Node$1: NodeInterface;
  * tree. It is returned as a convenience in certain cases to narrow a value
  * further than the more generic `Node` union.
  */
-type Descendant = Element$1 | Text$1;
+type Descendant = Element$1 | ObjectNode | Text$1;
 /**
  * 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
@@ -1020,7 +802,7 @@ 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'> | Omit<Text$1, 'text'>;
+type NodeProps = Omit<Editor$1, 'children'> | Omit<Element$1, 'children'> | ObjectNode | Omit<Text$1, 'text'>;
 type BaseInsertNodeOperation = {
   type: 'insert_node';
   path: Path$1;
@@ -1437,14 +1219,6 @@ interface RangeInterface {
   transform: (range: Range, op: Operation, options?: RangeTransformOptions) => Range | null;
 }
 declare const Range: RangeInterface;
-/**
- * Extendable Custom Types Interface
- */
-type ExtendableTypes = 'Editor' | 'Element' | 'Text' | 'Selection' | 'Range' | 'Point' | 'Operation' | 'InsertNodeOperation' | 'InsertTextOperation' | 'MergeNodeOperation' | 'MoveNodeOperation' | 'RemoveNodeOperation' | 'RemoveTextOperation' | 'SetNodeOperation' | 'SetSelectionOperation' | 'SplitNodeOperation';
-interface CustomTypes {
-  [key: string]: unknown;
-}
-type ExtendedType<K$1 extends ExtendableTypes, B> = unknown extends CustomTypes[K$1] ? B : CustomTypes[K$1];
 /**
  * `Text` objects represent the nodes that contain the actual text content of a
  * Slate document along with any formatting properties. They are always leaf
@@ -1481,11 +1255,11 @@ interface TextInterface {
   /**
    * Check if a value implements the `Text` interface.
    */
-  isText: (value: any) => value is Text$1;
+  isText: (value: any, schema: EditorSchema) => value is Text$1;
   /**
    * Check if a value is a list of `Text` objects.
    */
-  isTextList: (value: any) => value is Text$1[];
+  isTextList: (value: any, schema: EditorSchema) => value is Text$1[];
   /**
    * Check if some props are a partial of Text.
    */
@@ -1513,6 +1287,65 @@ interface GeneralTransforms {
   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;
+  /**
+   * 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$1>(editor: Editor$1, options?: {
+    at?: Location;
+    match?: NodeMatch<T>;
+    mode?: RangeMode;
+    hanging?: boolean;
+    voids?: boolean;
+  }) => void;
+  /**
+   * Move the nodes at a location to a new location.
+   */
+  moveNodes: <T extends Node$1>(editor: Editor$1, options: {
+    at?: Location;
+    match?: NodeMatch<T>;
+    mode?: MaximizeMode;
+    to: Path$1;
+    voids?: boolean;
+  }) => 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;
+  /**
+   * Split the nodes at a specific location.
+   */
+  splitNodes: <T extends Node$1>(editor: Editor$1, options?: {
+    at?: Location;
+    match?: NodeMatch<T>;
+    mode?: RangeMode;
+    always?: boolean;
+    height?: number;
+    voids?: boolean;
+  }) => void;
+}
+declare const NodeTransforms: NodeTransforms;
 interface SelectionCollapseOptions {
   edge?: SelectionEdge;
 }
@@ -1522,9 +1355,6 @@ interface SelectionMoveOptions {
   reverse?: boolean;
   edge?: SelectionEdge;
 }
-interface SelectionSetPointOptions {
-  edge?: SelectionEdge;
-}
 interface SelectionTransforms {
   /**
    * Collapse the selection.
@@ -1542,10 +1372,6 @@ interface SelectionTransforms {
    * Set the selection to a new value.
    */
   select: (editor: Editor$1, target: Location) => void;
-  /**
-   * Set new properties on one of the selection's points.
-   */
-  setPoint: (editor: Editor$1, props: Partial<Point>, options?: SelectionSetPointOptions) => void;
   /**
    * Set new properties on the selection.
    */
@@ -1553,10 +1379,6 @@ interface SelectionTransforms {
 }
 declare const SelectionTransforms: SelectionTransforms;
 declare const Transforms: GeneralTransforms & NodeTransforms & SelectionTransforms & TextTransforms;
-/**
- * @public
- */
-type EditorSchema = Schema;
 type DecoratedRange = BaseRange & {
   rangeDecoration: RangeDecoration;
 };
@@ -1596,6 +1418,10 @@ declare class Key {
   id: string;
   constructor();
 }
+type Action = {
+  at?: Point | Range;
+  run: () => void;
+};
 /**
  * A DOM-specific version of the `Editor` interface.
  */
@@ -1605,10 +1431,35 @@ interface DOMEditor extends BaseEditor {
   hasSelectableTarget: (editor: Editor$1, target: EventTarget | null) => boolean;
   hasTarget: (editor: Editor$1, target: EventTarget | null) => target is DOMNode;
   insertData: (data: DataTransfer) => void;
-  insertFragmentData: (data: DataTransfer) => boolean;
   insertTextData: (data: DataTransfer) => boolean;
   isTargetInsideNonReadonlyVoid: (editor: Editor$1, target: EventTarget | null) => boolean;
   setFragmentData: (data: DataTransfer, originEvent?: 'drag' | 'copy' | 'cut') => void;
+  isNodeMapDirty: boolean;
+  domWindow: Window | null;
+  domElement: HTMLElement | null;
+  domPlaceholder: string;
+  domPlaceholderElement: HTMLElement | null;
+  keyToElement: WeakMap<Key, HTMLElement>;
+  nodeToIndex: WeakMap<Node$1, number>;
+  nodeToParent: WeakMap<Node$1, Ancestor>;
+  elementToNode: WeakMap<HTMLElement, Node$1>;
+  nodeToElement: WeakMap<Node$1, HTMLElement>;
+  nodeToKey: WeakMap<Node$1, Key>;
+  changeVersion: MutableRefObject<number>;
+  readOnly: boolean;
+  focused: boolean;
+  composing: boolean;
+  userSelection: RangeRef | null;
+  onContextChange: ((options?: {
+    operation?: Operation;
+  }) => void) | null;
+  scheduleFlush: (() => void) | null;
+  pendingInsertionMarks: Partial<Text$1> | null;
+  userMarks: Partial<Text$1> | null;
+  pendingDiffs: TextDiff[];
+  pendingAction: Action | null;
+  pendingSelection: Range | null;
+  forceRender: (() => void) | null;
 }
 interface DOMEditorInterface {
   /**
@@ -1675,18 +1526,6 @@ interface DOMEditorInterface {
    * Check if the target is in the editor.
    */
   hasTarget: (editor: Editor$1, target: EventTarget | null) => target is DOMNode;
-  /**
-   * Insert data from a `DataTransfer` into the editor.
-   */
-  insertData: (editor: Editor$1, data: DataTransfer) => void;
-  /**
-   * Insert fragment data from a `DataTransfer` into the editor.
-   */
-  insertFragmentData: (editor: Editor$1, data: DataTransfer) => boolean;
-  /**
-   * Insert text data from a `DataTransfer` into the editor.
-   */
-  insertTextData: (editor: Editor$1, data: DataTransfer) => boolean;
   /**
    * Check if the user is currently composing inside the editor.
    */
@@ -1749,6 +1588,46 @@ interface DOMEditorInterface {
   }) => T extends true ? Range | null : Range;
 }
 declare const DOMEditor: DOMEditorInterface;
+interface ChunkTree {
+  type: 'root';
+  children: ChunkDescendant[];
+  /**
+   * The keys of any Slate nodes that have been moved using move_node since the
+   * last render
+   *
+   * Detecting when a node has been moved to a different position in the
+   * children array is impossible to do efficiently while reconciling the chunk
+   * tree. This interferes with the reconciliation logic since it is treated as
+   * if the intermediate nodes were inserted and removed, causing them to be
+   * re-chunked unnecessarily.
+   *
+   * This set is used to detect when a node has been moved so that this case
+   * can be handled correctly and efficiently.
+   */
+  movedNodeKeys: Set<Key>;
+  /**
+   * The chunks whose descendants have been modified during the most recent
+   * reconciliation
+   *
+   * Used to determine when the otherwise memoized React components for each
+   * chunk should be re-rendered.
+   */
+  modifiedChunks: Set<Chunk>;
+}
+interface Chunk {
+  type: 'chunk';
+  key: Key;
+  parent: ChunkAncestor;
+  children: ChunkDescendant[];
+}
+interface ChunkLeaf {
+  type: 'leaf';
+  key: Key;
+  node: Descendant;
+  index: number;
+}
+type ChunkAncestor = ChunkTree | Chunk;
+type ChunkDescendant = Chunk | ChunkLeaf;
 /**
  * A React and DOM-specific version of the `Editor` interface.
  */
@@ -1759,15 +1638,15 @@ interface ReactEditor extends DOMEditor {
    * disabled.
    */
   getChunkSize: (node: Ancestor) => number | null;
+  keyToChunkTree: WeakMap<Key, ChunkTree>;
 }
 interface ReactEditorInterface extends DOMEditorInterface {}
 declare const ReactEditor: ReactEditorInterface;
-interface VoidElement {
+interface ObjectElement {
   _type: string;
   _key: string;
   children: Descendant[];
-  __inline: boolean;
-  value: Record<string, unknown>;
+  [key: string]: unknown;
 }
 interface SlateTextBlock extends Omit<PortableTextTextBlock, 'children'> {
   children: Descendant[];
@@ -1775,7 +1654,8 @@ interface SlateTextBlock extends Omit<PortableTextTextBlock, 'children'> {
 declare module '../slate/index' {
   interface CustomTypes {
     Editor: BaseEditor & ReactEditor & PortableTextSlateEditor;
-    Element: SlateTextBlock | VoidElement;
+    Element: SlateTextBlock | ObjectElement;
+    ObjectNode: ObjectElement;
     Text: PortableTextSpan;
   }
 }
@@ -1800,6 +1680,8 @@ interface PortableTextSlateEditor extends ReactEditor {
   isTextBlock: (value: unknown) => value is PortableTextTextBlock;
   isTextSpan: (value: unknown) => value is PortableTextSpan;
   isListBlock: (value: unknown) => value is PortableTextListBlock;
+  isObjectNode: (value: unknown) => boolean;
+  schema: EditorSchema;
   decoratedRanges: Array<DecoratedRange>;
   decoratorState: Record<string, boolean | undefined>;
   blockIndexMap: Map<string, number>;
@@ -1809,7 +1691,6 @@ interface PortableTextSlateEditor extends ReactEditor {
   listIndexMap: Map<string, number>;
   remotePatches: Array<RemotePatch>;
   undoStepId: string | undefined;
-  value: Array<PortableTextBlock>;
   isDeferringMutations: boolean;
   isNormalizingNode: boolean;
   isPatching: boolean;
@@ -1996,7 +1877,7 @@ declare class PortableTextEditor {
    */
   static delete: (editor: PortableTextEditor, selection: EditorSelection, options?: EditableAPIDeleteOptions) => void;
   static findDOMNode: (editor: PortableTextEditor, element: PortableTextBlock | PortableTextChild) => Node | undefined;
-  static findByPath: (editor: PortableTextEditor, path: Path) => [_portabletext_schema5.PortableTextTextBlock<PortableTextObject | _portabletext_schema5.PortableTextSpan> | PortableTextObject | _portabletext_schema5.PortableTextSpan | undefined, Path | undefined];
+  static findByPath: (editor: PortableTextEditor, path: Path) => [_portabletext_schema6.PortableTextTextBlock<PortableTextObject | _portabletext_schema6.PortableTextSpan> | PortableTextObject | _portabletext_schema6.PortableTextSpan | undefined, Path | undefined];
   /**
    * @deprecated
    * Use `editor.send(...)` instead
@@ -2334,7 +2215,7 @@ type PortableTextEditableProps = Omit<TextareaHTMLAttributes<HTMLDivElement>, 'o
  * ```
  * @group Components
  */
-declare const PortableTextEditable: react10.ForwardRefExoticComponent<Omit<PortableTextEditableProps, "ref"> & react10.RefAttributes<Omit<HTMLDivElement, "as" | "onPaste" | "onBeforeInput">>>;
+declare const PortableTextEditable: react8.ForwardRefExoticComponent<Omit<PortableTextEditableProps, "ref"> & react8.RefAttributes<Omit<HTMLDivElement, "as" | "onPaste" | "onBeforeInput">>>;
 /** @beta */
 interface EditableAPIDeleteOptions {
   mode?: 'blocks' | 'children' | 'selected';
@@ -2391,8 +2272,8 @@ interface EditableAPI {
   isCollapsedSelection: () => boolean;
   isExpandedSelection: () => boolean;
   isMarkActive: (mark: string) => boolean;
-  isSelectionsOverlapping: (selectionA: EditorSelection, selectionB: EditorSelection) => boolean;
   isVoid: (element: PortableTextBlock | PortableTextChild) => boolean;
+  isSelectionsOverlapping: (selectionA: EditorSelection, selectionB: EditorSelection) => boolean;
   marks: () => string[];
   redo: () => void;
   removeAnnotation: <TSchemaType extends {
@@ -2970,7 +2851,7 @@ declare const editorMachine: xstate73.StateMachine<{
   initialValue?: Array<PortableTextBlock>;
 }, xstate73.NonReducibleUnknown, InternalPatchEvent | MutationEvent | PatchesEvent | {
   type: "blurred";
-  event: react10.FocusEvent<HTMLDivElement, Element>;
+  event: react8.FocusEvent<HTMLDivElement, Element>;
 } | {
   type: "done loading";
 } | {
@@ -2982,7 +2863,7 @@ declare const editorMachine: xstate73.StateMachine<{
   data: unknown;
 } | {
   type: "focused";
-  event: react10.FocusEvent<HTMLDivElement, Element>;
+  event: react8.FocusEvent<HTMLDivElement, Element>;
 } | {
   type: "invalid value";
   resolution: InvalidValueResolution | null;
@@ -3467,18 +3348,6 @@ type EditorDom = {
     };
   }) => void;
 };
-/**
- * Callback for the `reconcile` action.
- *
- * Receives a fresh snapshot reflecting the editor state after all preceding
- * actions in the same action set have been processed. Returns an array of
- * actions that will be executed in the same undo step.
- *
- * @beta
- */
-type ReconcileCallback = (payload: {
-  snapshot: EditorSnapshot;
-}) => Array<PickFromUnion<BehaviorAction, 'type', 'raise'> | PickFromUnion<BehaviorAction, 'type', 'execute'>>;
 /**
  * @beta
  */
@@ -3518,9 +3387,6 @@ type BehaviorAction = {
      */
     send: (event: ExternalBehaviorEvent) => void;
   }) => void;
-} | {
-  type: 'reconcile';
-  reconcile: ReconcileCallback;
 };
 /**
  * Directly executes an event, bypassing all Behavior matching.
@@ -3655,39 +3521,6 @@ declare function raise(event: SyntheticBehaviorEvent | CustomBehaviorEvent): Pic
  * @beta
  */
 declare function effect(effect: PickFromUnion<BehaviorAction, 'type', 'effect'>['effect']): PickFromUnion<BehaviorAction, 'type', 'effect'>;
-/**
- * Reads a fresh snapshot after preceding actions and returns correction actions.
- *
- * Use `reconcile` when you need to inspect the editor state after a `forward`
- * or other action has been processed, and then apply corrections based on the
- * actual result. The corrections are applied in the same undo step as the
- * preceding actions.
- *
- * The callback receives a fresh snapshot reflecting the current editor state
- * and must return an array of `raise` or `execute` actions.
- *
- * @example
- * ```ts
- * // Forward text insertion, then fix marks based on actual state
- * defineBehavior({
- *   on: 'insert.text',
- *   actions: [
- *     ({event}) => [
- *       forward(event),
- *       reconcile(({snapshot}) => {
- *         const block = selectors.getFocusTextBlock(snapshot)
- *         if (!block) return []
- *         // Compute corrections based on actual post-forward state
- *         return [raise({type: 'decorator.add', decorator: 'strong', at: range})]
- *       }),
- *     ],
- *   ],
- * })
- * ```
- *
- * @beta
- */
-declare function reconcile(reconcile: ReconcileCallback): PickFromUnion<BehaviorAction, 'type', 'reconcile'>;
 /**
  * @beta
  */
@@ -3696,5 +3529,5 @@ type BehaviorActionSet<TBehaviorEvent, TGuardResponse> = (payload: {
   event: TBehaviorEvent;
   dom: EditorDom;
 }, guardResponse: TGuardResponse) => Array<BehaviorAction>;
-export { EditorSnapshot as $, PortableTextObject$1 as A, PortableTextEditor as At, usePortableTextEditorSelection as B, InlineObjectDefinition as C, RenderListItemFunction as Ct, Patch$1 as D, PortableTextEditable as Dt, ListSchemaType$1 as E, ScrollSelectionIntoViewFunction as Et, StyleSchemaType$1 as F, BlockPath as Ft, EditorProviderProps as G, EditorSelector as H, defineSchema as I, ChildPath as It, EditorEvent as J, Editor as K, BlockOffset as L, KeyedSegment as Lt, PortableTextTextBlock$1 as M, MutationEvent as Mt, SchemaDefinition$1 as N, EditorSchema as Nt, PortableTextBlock$1 as O, PortableTextEditableProps as Ot, StyleDefinition as P, AnnotationPath as Pt, EditorContext as Q, useEditor as R, Path as Rt, FieldDefinition as S, RenderEditableFunction as St, ListDefinition as T, RenderStyleFunction as Tt, useEditorSelector as U, usePortableTextEditor as V, EditorProvider as W, defineBehavior as X, Behavior as Y, BehaviorGuard as Z, BaseDefinition as _, RangeDecorationOnMovedDetails as _t, execute as a, BlockRenderProps as at, DecoratorDefinition as b, RenderChildFunction as bt, reconcile as c, EditorSelection as ct, InsertPlacement as d, OnCopyFn as dt, AddedAnnotationPaths as et, NativeBehaviorEvent as f, OnPasteFn as ft, AnnotationSchemaType$1 as g, RangeDecoration as gt, AnnotationDefinition as h, PasteData as ht, effect as i, BlockListItemRenderProps as it, PortableTextSpan$1 as j, EditorEmittedEvent as jt, PortableTextChild$1 as k, HotkeyOptions as kt, BehaviorEvent as l, EditorSelectionPoint as lt, PatchesEvent as m, OnPasteResultOrPromise as mt, BehaviorActionSet as n, BlockChildRenderProps as nt, forward as o, BlockStyleRenderProps as ot, SyntheticBehaviorEvent as p, OnPasteResult as pt, EditorConfig as q, ReconcileCallback as r, BlockDecoratorRenderProps as rt, raise as s, EditableAPIDeleteOptions as st, BehaviorAction as t, BlockAnnotationRenderProps as tt, CustomBehaviorEvent as u, InvalidValueResolution as ut, BlockObjectDefinition as v, RenderAnnotationFunction as vt, InlineObjectSchemaType$1 as w, RenderPlaceholderFunction as wt, DecoratorSchemaType$1 as x, RenderDecoratorFunction as xt, BlockObjectSchemaType$1 as y, RenderBlockFunction as yt, defaultKeyGenerator as z };
+export { BlockAnnotationRenderProps as $, PortableTextTextBlock$1 as A, MutationEvent as At, EditorSelector as B, ListDefinition as C, RenderStyleFunction as Ct, PortableTextChild$1 as D, HotkeyOptions as Dt, PortableTextBlock$1 as E, PortableTextEditableProps as Et, BlockOffset as F, KeyedSegment as Ft, EditorConfig as G, EditorProvider as H, useEditor as I, Path as It, defineBehavior as J, EditorEvent as K, defaultKeyGenerator as L, StyleDefinition as M, AnnotationPath as Mt, StyleSchemaType$1 as N, BlockPath as Nt, PortableTextObject$1 as O, PortableTextEditor as Ot, defineSchema as P, ChildPath as Pt, AddedAnnotationPaths as Q, usePortableTextEditorSelection as R, InlineObjectSchemaType$1 as S, RenderPlaceholderFunction as St, Patch$1 as T, PortableTextEditable as Tt, EditorProviderProps as U, useEditorSelector as V, Editor as W, EditorContext as X, BehaviorGuard as Y, EditorSnapshot as Z, BlockObjectSchemaType$1 as _, RenderBlockFunction as _t, forward as a, EditableAPIDeleteOptions as at, FieldDefinition as b, RenderEditableFunction as bt, CustomBehaviorEvent as c, InvalidValueResolution as ct, SyntheticBehaviorEvent as d, OnPasteResult as dt, BlockChildRenderProps as et, PatchesEvent as f, OnPasteResultOrPromise as ft, BlockObjectDefinition as g, RenderAnnotationFunction as gt, BaseDefinition as h, RangeDecorationOnMovedDetails as ht, execute as i, BlockStyleRenderProps as it, SchemaDefinition$1 as j, EditorSchema as jt, PortableTextSpan$1 as k, EditorEmittedEvent as kt, InsertPlacement as l, OnCopyFn as lt, AnnotationSchemaType$1 as m, RangeDecoration as mt, BehaviorActionSet as n, BlockListItemRenderProps as nt, raise as o, EditorSelection as ot, AnnotationDefinition as p, PasteData as pt, Behavior as q, effect as r, BlockRenderProps as rt, BehaviorEvent as s, EditorSelectionPoint as st, BehaviorAction as t, BlockDecoratorRenderProps as tt, NativeBehaviorEvent as u, OnPasteFn as ut, DecoratorDefinition as v, RenderChildFunction as vt, ListSchemaType$1 as w, ScrollSelectionIntoViewFunction as wt, InlineObjectDefinition as x, RenderListItemFunction as xt, DecoratorSchemaType$1 as y, RenderDecoratorFunction as yt, usePortableTextEditor as z };
 //# sourceMappingURL=behavior.types.action.d.ts.map