@portabletext/editor 1.50.8 → 1.52.0

package/lib/plugins/index.d.ts

@@ -1,47 +1,15 @@
 import type {Patch} from '@portabletext/patches'
 import type {
-  ArraySchemaType,
-  BlockDecoratorDefinition,
-  BlockListDefinition,
-  BlockStyleDefinition,
   KeyedSegment,
-  ObjectSchemaType,
   Path,
   PortableTextBlock,
   PortableTextChild,
-  PortableTextListBlock,
   PortableTextObject,
-  PortableTextSpan,
   PortableTextTextBlock,
 } from '@sanity/types'
-import {FocusEvent as FocusEvent_2, JSX, default as React_2} from 'react'
-import type {KeyboardEvent as KeyboardEvent_2} from 'react'
-import type {Descendant, Operation} from 'slate'
-import type {DOMNode} from 'slate-dom'
-import type {ReactEditor} from 'slate-react'
-import {
-  ActionArgs,
-  ActionFunction,
-  ActorRef,
-  ActorRefFrom,
-  ActorRefFromLogic,
-  AnyActorLogic,
-  AnyActorRef,
-  AnyEventObject,
-  ConditionalRequired,
-  InputFrom,
-  IsNotNever,
-  MachineSnapshot,
-  MetaObject,
-  NonReducibleUnknown,
-  RequiredLogicInput,
-  StateMachine,
-  StateValue,
-  Values,
-} from 'xstate'
-import type {EventObject, Snapshot} from 'xstate'
-import {GuardArgs} from 'xstate/guards'
-import {InvalidValueResolution} from '..'
+import type {FocusEvent as FocusEvent_2} from 'react'
+import {JSX, default as React_2} from 'react'
+import type {ActorRef, EventObject, Snapshot} from 'xstate'
 
 declare type AbstractBehaviorEvent =
   | {
@@ -146,6 +114,7 @@ declare type AbstractBehaviorEvent =
       type: StrictExtract<SyntheticBehaviorEventType, 'insert.blocks'>
       blocks: Array<BlockWithOptionalKey>
       placement: InsertPlacement
+      select?: 'start' | 'end' | 'none'
     }
   | {
       type: StrictExtract<SyntheticBehaviorEventType, 'insert.break'>
@@ -297,15 +266,11 @@ declare type BehaviorActionSet<TBehaviorEvent, TGuardResponse> = (
   payload: {
     snapshot: EditorSnapshot
     event: TBehaviorEvent
+    dom: EditorDom
   },
   guardResponse: TGuardResponse,
 ) => Array<BehaviorAction>
 
-declare type BehaviorConfig = {
-  behavior: Behavior
-  priority: EditorPriority
-}
-
 /**
  * @beta
  */
@@ -325,6 +290,7 @@ declare type BehaviorEventTypeNamespace =
 declare type BehaviorGuard<TBehaviorEvent, TGuardResponse> = (payload: {
   snapshot: EditorSnapshot
   event: TBehaviorEvent
+  dom: EditorDom
 }) => TGuardResponse | false
 
 /**
@@ -459,6 +425,8 @@ declare type DragBehaviorEvent =
   | {
       type: StrictExtract<NativeBehaviorEventType, 'drag.dragstart'>
       originEvent: {
+        clientX: number
+        clientY: number
         dataTransfer: DataTransfer
       }
       position: Pick<EventPosition, 'selection'>
@@ -487,6 +455,7 @@ declare type DragBehaviorEvent =
       originEvent: {
         dataTransfer: DataTransfer
       }
+      dragOrigin?: Pick<EventPosition, 'selection'>
       position: EventPosition
     }
   | {
@@ -494,6 +463,7 @@ declare type DragBehaviorEvent =
       originEvent: {
         dataTransfer: DataTransfer
       }
+      dragOrigin?: Pick<EventPosition, 'selection'>
       position: EventPosition
     }
   | {
@@ -503,95 +473,6 @@ declare type DragBehaviorEvent =
       }
     }
 
-/** @beta */
-declare interface EditableAPI {
-  activeAnnotations: () => PortableTextObject[]
-  isAnnotationActive: (annotationType: PortableTextObject['_type']) => boolean
-  addAnnotation: <
-    TSchemaType extends {
-      name: string
-    },
-  >(
-    type: TSchemaType,
-    value?: {
-      [prop: string]: unknown
-    },
-  ) =>
-    | {
-        markDefPath: Path
-        markDefPaths: Array<Path>
-        spanPath: Path
-      }
-    | undefined
-  blur: () => void
-  delete: (
-    selection: EditorSelection,
-    options?: EditableAPIDeleteOptions,
-  ) => void
-  findByPath: (
-    path: Path,
-  ) => [PortableTextBlock | PortableTextChild | undefined, Path | undefined]
-  findDOMNode: (
-    element: PortableTextBlock | PortableTextChild,
-  ) => DOMNode | undefined
-  focus: () => void
-  focusBlock: () => PortableTextBlock | undefined
-  focusChild: () => PortableTextChild | undefined
-  getSelection: () => EditorSelection
-  getFragment: () => PortableTextBlock[] | undefined
-  getValue: () => PortableTextBlock[] | undefined
-  hasBlockStyle: (style: string) => boolean
-  hasListStyle: (listStyle: string) => boolean
-  insertBlock: <
-    TSchemaType extends {
-      name: string
-    },
-  >(
-    type: TSchemaType,
-    value?: {
-      [prop: string]: unknown
-    },
-  ) => Path
-  insertChild: <
-    TSchemaType extends {
-      name: string
-    },
-  >(
-    type: TSchemaType,
-    value?: {
-      [prop: string]: unknown
-    },
-  ) => Path
-  insertBreak: () => void
-  isCollapsedSelection: () => boolean
-  isExpandedSelection: () => boolean
-  isMarkActive: (mark: string) => boolean
-  isSelectionsOverlapping: (
-    selectionA: EditorSelection,
-    selectionB: EditorSelection,
-  ) => boolean
-  isVoid: (element: PortableTextBlock | PortableTextChild) => boolean
-  marks: () => string[]
-  redo: () => void
-  removeAnnotation: <
-    TSchemaType extends {
-      name: string
-    },
-  >(
-    type: TSchemaType,
-  ) => void
-  select: (selection: EditorSelection) => void
-  toggleBlockStyle: (blockStyle: string) => void
-  toggleList: (listStyle: string) => void
-  toggleMark: (mark: string) => void
-  undo: () => void
-}
-
-/** @beta */
-declare interface EditableAPIDeleteOptions {
-  mode?: 'blocks' | 'children' | 'selected'
-}
-
 /**
  * @public
  */
@@ -605,11 +486,6 @@ declare type Editor = {
   on: ActorRef<Snapshot<unknown>, EventObject, EditorEmittedEvent>['on']
 }
 
-/**
- * @internal
- */
-declare type EditorActor = ActorRefFrom<typeof editorMachine>
-
 /**
  * @public
  */
@@ -622,6 +498,26 @@ declare type EditorContext = {
   value: Array<PortableTextBlock>
 }
 
+declare type EditorDom = {
+  getBlockNodes: (snapshot: EditorSnapshot) => Array<Node>
+  getChildNodes: (snapshot: EditorSnapshot) => Array<Node>
+  /**
+   * Let the Editor set the drag ghost. This is to be sure that it will get
+   * properly removed again when the drag ends.
+   */
+  setDragGhost: ({
+    event,
+    ghost,
+  }: {
+    event: PickFromUnion<BehaviorEvent, 'type', 'drag.dragstart'>
+    ghost: {
+      element: HTMLElement
+      x: number
+      y: number
+    }
+  }) => void
+}
+
 /**
  * @public
  */
@@ -646,7 +542,7 @@ declare type EditorEmittedEvent =
     }
   | {
       type: 'invalid value'
-      resolution: InvalidValueResolution_2 | null
+      resolution: InvalidValueResolution | null
       value: Array<PortableTextBlock> | undefined
     }
   | {
@@ -683,1764 +579,6 @@ declare type EditorEvent =
       value: Array<PortableTextBlock> | undefined
     }
 
-/**
- * @internal
- */
-declare const editorMachine: StateMachine<
-  {
-    behaviors: Set<BehaviorConfig>
-    converters: Set<Converter>
-    getLegacySchema: () => PortableTextMemberSchemaTypes
-    keyGenerator: () => string
-    pendingEvents: Array<InternalPatchEvent | MutationEvent>
-    pendingIncomingPatchesEvents: Array<PatchesEvent>
-    schema: EditorSchema
-    initialReadOnly: boolean
-    maxBlocks: number | undefined
-    selection: EditorSelection
-    initialValue: Array<PortableTextBlock> | undefined
-    internalDrag?: {
-      ghost?: HTMLElement
-      origin: Pick<EventPosition, 'selection'>
-    }
-    slateEditor?: PortableTextSlateEditor
-  },
-  | InternalPatchEvent
-  | MutationEvent
-  | PatchesEvent
-  | {
-      type: 'update readOnly'
-      readOnly: boolean
-    }
-  | {
-      type: 'update maxBlocks'
-      maxBlocks: number | undefined
-    }
-  | {
-      type: 'add behavior'
-      behaviorConfig: BehaviorConfig
-    }
-  | {
-      type: 'remove behavior'
-      behaviorConfig: BehaviorConfig
-    }
-  | {
-      type: 'blur'
-      editor: PortableTextSlateEditor
-    }
-  | {
-      type: 'focus'
-      editor: PortableTextSlateEditor
-    }
-  | {
-      type: 'normalizing'
-    }
-  | {
-      type: 'update selection'
-      selection: EditorSelection
-    }
-  | {
-      type: 'done normalizing'
-    }
-  | {
-      type: 'done syncing value'
-    }
-  | {
-      type: 'syncing value'
-    }
-  | {
-      type: 'behavior event'
-      behaviorEvent: BehaviorEvent
-      editor: PortableTextSlateEditor
-      nativeEvent?: {
-        preventDefault: () => void
-      }
-    }
-  | {
-      type: 'dragstart'
-      origin: Pick<EventPosition, 'selection'>
-      ghost?: HTMLElement
-    }
-  | {
-      type: 'dragend'
-    }
-  | {
-      type: 'drop'
-    },
-  {},
-  never,
-  Values<{
-    'add behavior to context': {
-      type: 'add behavior to context'
-      params: NonReducibleUnknown
-    }
-    'remove behavior from context': {
-      type: 'remove behavior from context'
-      params: NonReducibleUnknown
-    }
-    'emit patch event': {
-      type: 'emit patch event'
-      params: NonReducibleUnknown
-    }
-    'emit mutation event': {
-      type: 'emit mutation event'
-      params: NonReducibleUnknown
-    }
-    'emit read only': {
-      type: 'emit read only'
-      params: NonReducibleUnknown
-    }
-    'emit editable': {
-      type: 'emit editable'
-      params: NonReducibleUnknown
-    }
-    'defer event': {
-      type: 'defer event'
-      params: NonReducibleUnknown
-    }
-    'emit pending events': {
-      type: 'emit pending events'
-      params: NonReducibleUnknown
-    }
-    'emit ready': {
-      type: 'emit ready'
-      params: NonReducibleUnknown
-    }
-    'clear pending events': {
-      type: 'clear pending events'
-      params: NonReducibleUnknown
-    }
-    'defer incoming patches': {
-      type: 'defer incoming patches'
-      params: NonReducibleUnknown
-    }
-    'emit pending incoming patches': {
-      type: 'emit pending incoming patches'
-      params: NonReducibleUnknown
-    }
-    'clear pending incoming patches': {
-      type: 'clear pending incoming patches'
-      params: NonReducibleUnknown
-    }
-    'handle blur': {
-      type: 'handle blur'
-      params: unknown
-    }
-    'handle focus': {
-      type: 'handle focus'
-      params: unknown
-    }
-    'handle behavior event': {
-      type: 'handle behavior event'
-      params: unknown
-    }
-  }>,
-  {
-    type: 'slate is busy'
-    params: unknown
-  },
-  never,
-  {
-    'edit mode':
-      | {
-          editable:
-            | 'dragging internally'
-            | 'idle'
-            | {
-                focusing: 'checking if busy' | 'busy'
-              }
-        }
-      | {
-          'read only': 'read only' | 'determine initial edit mode'
-        }
-    'setup':
-      | 'setting up'
-      | {
-          'set up': {
-            'value sync': 'syncing value' | 'idle'
-            'writing':
-              | 'dirty'
-              | {
-                  pristine: 'normalizing' | 'idle'
-                }
-          }
-        }
-  },
-  'dragging internally',
-  {
-    converters?: Array<Converter>
-    getLegacySchema: () => PortableTextMemberSchemaTypes
-    keyGenerator: () => string
-    maxBlocks?: number
-    readOnly?: boolean
-    schema: EditorSchema
-    initialValue?: Array<PortableTextBlock>
-  },
-  NonReducibleUnknown,
-  | InternalPatchEvent
-  | MutationEvent
-  | PatchesEvent
-  | {
-      type: 'blurred'
-      event: FocusEvent_2<HTMLDivElement, Element>
-    }
-  | {
-      type: 'done loading'
-    }
-  | {
-      type: 'editable'
-    }
-  | {
-      type: 'error'
-      name: string
-      description: string
-      data: unknown
-    }
-  | {
-      type: 'focused'
-      event: FocusEvent_2<HTMLDivElement, Element>
-    }
-  | {
-      type: 'invalid value'
-      resolution: InvalidValueResolution | null
-      value: Array<PortableTextBlock> | undefined
-    }
-  | {
-      type: 'loading'
-    }
-  | {
-      type: 'read only'
-    }
-  | {
-      type: 'ready'
-    }
-  | {
-      type: 'selection'
-      selection: EditorSelection
-    }
-  | {
-      type: 'value changed'
-      value: Array<PortableTextBlock> | undefined
-    },
-  MetaObject,
-  {
-    readonly id: 'editor'
-    readonly context: ({
-      input,
-    }: {
-      spawn: {
-        <TSrc extends never>(
-          logic: TSrc,
-          ...[options]: never
-        ): ActorRefFromLogic<never>
-        <TLogic extends AnyActorLogic>(
-          src: TLogic,
-          ...[options]: ConditionalRequired<
-            [
-              options?:
-                | ({
-                    id?: never
-                    systemId?: string
-                    input?: InputFrom<TLogic> | undefined
-                    syncSnapshot?: boolean
-                  } & {[K in RequiredLogicInput<TLogic>]: unknown})
-                | undefined,
-            ],
-            IsNotNever<RequiredLogicInput<TLogic>>
-          >
-        ): ActorRefFromLogic<TLogic>
-      }
-      input: {
-        converters?: Array<Converter>
-        getLegacySchema: () => PortableTextMemberSchemaTypes
-        keyGenerator: () => string
-        maxBlocks?: number
-        readOnly?: boolean
-        schema: EditorSchema
-        initialValue?: Array<PortableTextBlock>
-      }
-      self: ActorRef<
-        MachineSnapshot<
-          {
-            behaviors: Set<BehaviorConfig>
-            converters: Set<Converter>
-            getLegacySchema: () => PortableTextMemberSchemaTypes
-            keyGenerator: () => string
-            pendingEvents: Array<InternalPatchEvent | MutationEvent>
-            pendingIncomingPatchesEvents: Array<PatchesEvent>
-            schema: EditorSchema
-            initialReadOnly: boolean
-            maxBlocks: number | undefined
-            selection: EditorSelection
-            initialValue: Array<PortableTextBlock> | undefined
-            internalDrag?: {
-              ghost?: HTMLElement
-              origin: Pick<EventPosition, 'selection'>
-            }
-            slateEditor?: PortableTextSlateEditor
-          },
-          | InternalPatchEvent
-          | MutationEvent
-          | PatchesEvent
-          | {
-              type: 'update readOnly'
-              readOnly: boolean
-            }
-          | {
-              type: 'update maxBlocks'
-              maxBlocks: number | undefined
-            }
-          | {
-              type: 'add behavior'
-              behaviorConfig: BehaviorConfig
-            }
-          | {
-              type: 'remove behavior'
-              behaviorConfig: BehaviorConfig
-            }
-          | {
-              type: 'blur'
-              editor: PortableTextSlateEditor
-            }
-          | {
-              type: 'focus'
-              editor: PortableTextSlateEditor
-            }
-          | {
-              type: 'normalizing'
-            }
-          | {
-              type: 'update selection'
-              selection: EditorSelection
-            }
-          | {
-              type: 'done normalizing'
-            }
-          | {
-              type: 'done syncing value'
-            }
-          | {
-              type: 'syncing value'
-            }
-          | {
-              type: 'behavior event'
-              behaviorEvent: BehaviorEvent
-              editor: PortableTextSlateEditor
-              nativeEvent?: {
-                preventDefault: () => void
-              }
-            }
-          | {
-              type: 'dragstart'
-              origin: Pick<EventPosition, 'selection'>
-              ghost?: HTMLElement
-            }
-          | {
-              type: 'dragend'
-            }
-          | {
-              type: 'drop'
-            },
-          Record<string, AnyActorRef | undefined>,
-          StateValue,
-          string,
-          unknown,
-          any,
-          any
-        >,
-        | InternalPatchEvent
-        | MutationEvent
-        | PatchesEvent
-        | {
-            type: 'update readOnly'
-            readOnly: boolean
-          }
-        | {
-            type: 'update maxBlocks'
-            maxBlocks: number | undefined
-          }
-        | {
-            type: 'add behavior'
-            behaviorConfig: BehaviorConfig
-          }
-        | {
-            type: 'remove behavior'
-            behaviorConfig: BehaviorConfig
-          }
-        | {
-            type: 'blur'
-            editor: PortableTextSlateEditor
-          }
-        | {
-            type: 'focus'
-            editor: PortableTextSlateEditor
-          }
-        | {
-            type: 'normalizing'
-          }
-        | {
-            type: 'update selection'
-            selection: EditorSelection
-          }
-        | {
-            type: 'done normalizing'
-          }
-        | {
-            type: 'done syncing value'
-          }
-        | {
-            type: 'syncing value'
-          }
-        | {
-            type: 'behavior event'
-            behaviorEvent: BehaviorEvent
-            editor: PortableTextSlateEditor
-            nativeEvent?: {
-              preventDefault: () => void
-            }
-          }
-        | {
-            type: 'dragstart'
-            origin: Pick<EventPosition, 'selection'>
-            ghost?: HTMLElement
-          }
-        | {
-            type: 'dragend'
-          }
-        | {
-            type: 'drop'
-          },
-        AnyEventObject
-      >
-    }) => {
-      behaviors: Set<never>
-      converters: Set<Converter>
-      getLegacySchema: () => PortableTextMemberSchemaTypes
-      keyGenerator: () => string
-      pendingEvents: never[]
-      pendingIncomingPatchesEvents: never[]
-      schema: EditorSchema
-      selection: null
-      initialReadOnly: boolean
-      maxBlocks: number | undefined
-      initialValue: PortableTextBlock[] | undefined
-    }
-    readonly on: {
-      readonly 'add behavior': {
-        readonly actions: 'add behavior to context'
-      }
-      readonly 'remove behavior': {
-        readonly actions: 'remove behavior from context'
-      }
-      readonly 'update maxBlocks': {
-        readonly actions: ActionFunction<
-          {
-            behaviors: Set<BehaviorConfig>
-            converters: Set<Converter>
-            getLegacySchema: () => PortableTextMemberSchemaTypes
-            keyGenerator: () => string
-            pendingEvents: Array<InternalPatchEvent | MutationEvent>
-            pendingIncomingPatchesEvents: Array<PatchesEvent>
-            schema: EditorSchema
-            initialReadOnly: boolean
-            maxBlocks: number | undefined
-            selection: EditorSelection
-            initialValue: Array<PortableTextBlock> | undefined
-            internalDrag?: {
-              ghost?: HTMLElement
-              origin: Pick<EventPosition, 'selection'>
-            }
-            slateEditor?: PortableTextSlateEditor
-          },
-          {
-            type: 'update maxBlocks'
-            maxBlocks: number | undefined
-          },
-          | InternalPatchEvent
-          | MutationEvent
-          | PatchesEvent
-          | {
-              type: 'update readOnly'
-              readOnly: boolean
-            }
-          | {
-              type: 'update maxBlocks'
-              maxBlocks: number | undefined
-            }
-          | {
-              type: 'add behavior'
-              behaviorConfig: BehaviorConfig
-            }
-          | {
-              type: 'remove behavior'
-              behaviorConfig: BehaviorConfig
-            }
-          | {
-              type: 'blur'
-              editor: PortableTextSlateEditor
-            }
-          | {
-              type: 'focus'
-              editor: PortableTextSlateEditor
-            }
-          | {
-              type: 'normalizing'
-            }
-          | {
-              type: 'update selection'
-              selection: EditorSelection
-            }
-          | {
-              type: 'done normalizing'
-            }
-          | {
-              type: 'done syncing value'
-            }
-          | {
-              type: 'syncing value'
-            }
-          | {
-              type: 'behavior event'
-              behaviorEvent: BehaviorEvent
-              editor: PortableTextSlateEditor
-              nativeEvent?: {
-                preventDefault: () => void
-              }
-            }
-          | {
-              type: 'dragstart'
-              origin: Pick<EventPosition, 'selection'>
-              ghost?: HTMLElement
-            }
-          | {
-              type: 'dragend'
-            }
-          | {
-              type: 'drop'
-            },
-          undefined,
-          never,
-          never,
-          never,
-          never,
-          never
-        >
-      }
-      readonly 'update selection': {
-        readonly actions: readonly [
-          ActionFunction<
-            {
-              behaviors: Set<BehaviorConfig>
-              converters: Set<Converter>
-              getLegacySchema: () => PortableTextMemberSchemaTypes
-              keyGenerator: () => string
-              pendingEvents: Array<InternalPatchEvent | MutationEvent>
-              pendingIncomingPatchesEvents: Array<PatchesEvent>
-              schema: EditorSchema
-              initialReadOnly: boolean
-              maxBlocks: number | undefined
-              selection: EditorSelection
-              initialValue: Array<PortableTextBlock> | undefined
-              internalDrag?: {
-                ghost?: HTMLElement
-                origin: Pick<EventPosition, 'selection'>
-              }
-              slateEditor?: PortableTextSlateEditor
-            },
-            {
-              type: 'update selection'
-              selection: EditorSelection
-            },
-            | InternalPatchEvent
-            | MutationEvent
-            | PatchesEvent
-            | {
-                type: 'update readOnly'
-                readOnly: boolean
-              }
-            | {
-                type: 'update maxBlocks'
-                maxBlocks: number | undefined
-              }
-            | {
-                type: 'add behavior'
-                behaviorConfig: BehaviorConfig
-              }
-            | {
-                type: 'remove behavior'
-                behaviorConfig: BehaviorConfig
-              }
-            | {
-                type: 'blur'
-                editor: PortableTextSlateEditor
-              }
-            | {
-                type: 'focus'
-                editor: PortableTextSlateEditor
-              }
-            | {
-                type: 'normalizing'
-              }
-            | {
-                type: 'update selection'
-                selection: EditorSelection
-              }
-            | {
-                type: 'done normalizing'
-              }
-            | {
-                type: 'done syncing value'
-              }
-            | {
-                type: 'syncing value'
-              }
-            | {
-                type: 'behavior event'
-                behaviorEvent: BehaviorEvent
-                editor: PortableTextSlateEditor
-                nativeEvent?: {
-                  preventDefault: () => void
-                }
-              }
-            | {
-                type: 'dragstart'
-                origin: Pick<EventPosition, 'selection'>
-                ghost?: HTMLElement
-              }
-            | {
-                type: 'dragend'
-              }
-            | {
-                type: 'drop'
-              },
-            undefined,
-            never,
-            never,
-            never,
-            never,
-            never
-          >,
-          ActionFunction<
-            {
-              behaviors: Set<BehaviorConfig>
-              converters: Set<Converter>
-              getLegacySchema: () => PortableTextMemberSchemaTypes
-              keyGenerator: () => string
-              pendingEvents: Array<InternalPatchEvent | MutationEvent>
-              pendingIncomingPatchesEvents: Array<PatchesEvent>
-              schema: EditorSchema
-              initialReadOnly: boolean
-              maxBlocks: number | undefined
-              selection: EditorSelection
-              initialValue: Array<PortableTextBlock> | undefined
-              internalDrag?: {
-                ghost?: HTMLElement
-                origin: Pick<EventPosition, 'selection'>
-              }
-              slateEditor?: PortableTextSlateEditor
-            },
-            {
-              type: 'update selection'
-              selection: EditorSelection
-            },
-            | InternalPatchEvent
-            | MutationEvent
-            | PatchesEvent
-            | {
-                type: 'update readOnly'
-                readOnly: boolean
-              }
-            | {
-                type: 'update maxBlocks'
-                maxBlocks: number | undefined
-              }
-            | {
-                type: 'add behavior'
-                behaviorConfig: BehaviorConfig
-              }
-            | {
-                type: 'remove behavior'
-                behaviorConfig: BehaviorConfig
-              }
-            | {
-                type: 'blur'
-                editor: PortableTextSlateEditor
-              }
-            | {
-                type: 'focus'
-                editor: PortableTextSlateEditor
-              }
-            | {
-                type: 'normalizing'
-              }
-            | {
-                type: 'update selection'
-                selection: EditorSelection
-              }
-            | {
-                type: 'done normalizing'
-              }
-            | {
-                type: 'done syncing value'
-              }
-            | {
-                type: 'syncing value'
-              }
-            | {
-                type: 'behavior event'
-                behaviorEvent: BehaviorEvent
-                editor: PortableTextSlateEditor
-                nativeEvent?: {
-                  preventDefault: () => void
-                }
-              }
-            | {
-                type: 'dragstart'
-                origin: Pick<EventPosition, 'selection'>
-                ghost?: HTMLElement
-              }
-            | {
-                type: 'dragend'
-              }
-            | {
-                type: 'drop'
-              },
-            undefined,
-            never,
-            never,
-            never,
-            never,
-            | InternalPatchEvent
-            | MutationEvent
-            | PatchesEvent
-            | {
-                type: 'blurred'
-                event: FocusEvent_2<HTMLDivElement, Element>
-              }
-            | {
-                type: 'done loading'
-              }
-            | {
-                type: 'editable'
-              }
-            | {
-                type: 'error'
-                name: string
-                description: string
-                data: unknown
-              }
-            | {
-                type: 'focused'
-                event: FocusEvent_2<HTMLDivElement, Element>
-              }
-            | {
-                type: 'invalid value'
-                resolution: InvalidValueResolution | null
-                value: Array<PortableTextBlock> | undefined
-              }
-            | {
-                type: 'loading'
-              }
-            | {
-                type: 'read only'
-              }
-            | {
-                type: 'ready'
-              }
-            | {
-                type: 'selection'
-                selection: EditorSelection
-              }
-            | {
-                type: 'value changed'
-                value: Array<PortableTextBlock> | undefined
-              }
-          >,
-        ]
-      }
-    }
-    readonly type: 'parallel'
-    readonly states: {
-      readonly 'edit mode': {
-        readonly initial: 'read only'
-        readonly states: {
-          readonly 'read only': {
-            readonly initial: 'determine initial edit mode'
-            readonly on: {
-              readonly 'behavior event': {
-                readonly actions: 'handle behavior event'
-                readonly guard: ({
-                  event,
-                }: GuardArgs<
-                  {
-                    behaviors: Set<BehaviorConfig>
-                    converters: Set<Converter>
-                    getLegacySchema: () => PortableTextMemberSchemaTypes
-                    keyGenerator: () => string
-                    pendingEvents: Array<InternalPatchEvent | MutationEvent>
-                    pendingIncomingPatchesEvents: Array<PatchesEvent>
-                    schema: EditorSchema
-                    initialReadOnly: boolean
-                    maxBlocks: number | undefined
-                    selection: EditorSelection
-                    initialValue: Array<PortableTextBlock> | undefined
-                    internalDrag?: {
-                      ghost?: HTMLElement
-                      origin: Pick<EventPosition, 'selection'>
-                    }
-                    slateEditor?: PortableTextSlateEditor
-                  },
-                  {
-                    type: 'behavior event'
-                    behaviorEvent: BehaviorEvent
-                    editor: PortableTextSlateEditor
-                    nativeEvent?: {
-                      preventDefault: () => void
-                    }
-                  }
-                >) => boolean
-              }
-            }
-            readonly states: {
-              readonly 'determine initial edit mode': {
-                readonly entry: readonly [() => void]
-                readonly exit: readonly [() => void]
-                readonly on: {
-                  readonly 'done syncing value': readonly [
-                    {
-                      readonly target: '#editor.edit mode.read only.read only'
-                      readonly guard: ({
-                        context,
-                      }: GuardArgs<
-                        {
-                          behaviors: Set<BehaviorConfig>
-                          converters: Set<Converter>
-                          getLegacySchema: () => PortableTextMemberSchemaTypes
-                          keyGenerator: () => string
-                          pendingEvents: Array<
-                            InternalPatchEvent | MutationEvent
-                          >
-                          pendingIncomingPatchesEvents: Array<PatchesEvent>
-                          schema: EditorSchema
-                          initialReadOnly: boolean
-                          maxBlocks: number | undefined
-                          selection: EditorSelection
-                          initialValue: Array<PortableTextBlock> | undefined
-                          internalDrag?: {
-                            ghost?: HTMLElement
-                            origin: Pick<EventPosition, 'selection'>
-                          }
-                          slateEditor?: PortableTextSlateEditor
-                        },
-                        {
-                          type: 'done syncing value'
-                        }
-                      >) => boolean
-                    },
-                    {
-                      readonly target: '#editor.edit mode.editable'
-                    },
-                  ]
-                }
-              }
-              readonly 'read only': {
-                readonly entry: readonly [() => void]
-                readonly exit: readonly [() => void]
-                readonly on: {
-                  readonly 'update readOnly': {
-                    readonly guard: ({
-                      event,
-                    }: GuardArgs<
-                      {
-                        behaviors: Set<BehaviorConfig>
-                        converters: Set<Converter>
-                        getLegacySchema: () => PortableTextMemberSchemaTypes
-                        keyGenerator: () => string
-                        pendingEvents: Array<InternalPatchEvent | MutationEvent>
-                        pendingIncomingPatchesEvents: Array<PatchesEvent>
-                        schema: EditorSchema
-                        initialReadOnly: boolean
-                        maxBlocks: number | undefined
-                        selection: EditorSelection
-                        initialValue: Array<PortableTextBlock> | undefined
-                        internalDrag?: {
-                          ghost?: HTMLElement
-                          origin: Pick<EventPosition, 'selection'>
-                        }
-                        slateEditor?: PortableTextSlateEditor
-                      },
-                      {
-                        type: 'update readOnly'
-                        readOnly: boolean
-                      }
-                    >) => boolean
-                    readonly target: '#editor.edit mode.editable'
-                    readonly actions: readonly ['emit editable']
-                  }
-                }
-              }
-            }
-          }
-          readonly 'editable': {
-            readonly on: {
-              readonly 'update readOnly': {
-                readonly guard: ({
-                  event,
-                }: GuardArgs<
-                  {
-                    behaviors: Set<BehaviorConfig>
-                    converters: Set<Converter>
-                    getLegacySchema: () => PortableTextMemberSchemaTypes
-                    keyGenerator: () => string
-                    pendingEvents: Array<InternalPatchEvent | MutationEvent>
-                    pendingIncomingPatchesEvents: Array<PatchesEvent>
-                    schema: EditorSchema
-                    initialReadOnly: boolean
-                    maxBlocks: number | undefined
-                    selection: EditorSelection
-                    initialValue: Array<PortableTextBlock> | undefined
-                    internalDrag?: {
-                      ghost?: HTMLElement
-                      origin: Pick<EventPosition, 'selection'>
-                    }
-                    slateEditor?: PortableTextSlateEditor
-                  },
-                  {
-                    type: 'update readOnly'
-                    readOnly: boolean
-                  }
-                >) => boolean
-                readonly target: '#editor.edit mode.read only.read only'
-                readonly actions: readonly ['emit read only']
-              }
-              readonly 'behavior event': {
-                readonly actions: 'handle behavior event'
-              }
-              readonly 'blur': {
-                readonly actions: 'handle blur'
-              }
-              readonly 'focus': {
-                readonly target: '.focusing'
-                readonly actions: readonly [
-                  ActionFunction<
-                    {
-                      behaviors: Set<BehaviorConfig>
-                      converters: Set<Converter>
-                      getLegacySchema: () => PortableTextMemberSchemaTypes
-                      keyGenerator: () => string
-                      pendingEvents: Array<InternalPatchEvent | MutationEvent>
-                      pendingIncomingPatchesEvents: Array<PatchesEvent>
-                      schema: EditorSchema
-                      initialReadOnly: boolean
-                      maxBlocks: number | undefined
-                      selection: EditorSelection
-                      initialValue: Array<PortableTextBlock> | undefined
-                      internalDrag?: {
-                        ghost?: HTMLElement
-                        origin: Pick<EventPosition, 'selection'>
-                      }
-                      slateEditor?: PortableTextSlateEditor
-                    },
-                    {
-                      type: 'focus'
-                      editor: PortableTextSlateEditor
-                    },
-                    | InternalPatchEvent
-                    | MutationEvent
-                    | PatchesEvent
-                    | {
-                        type: 'update readOnly'
-                        readOnly: boolean
-                      }
-                    | {
-                        type: 'update maxBlocks'
-                        maxBlocks: number | undefined
-                      }
-                    | {
-                        type: 'add behavior'
-                        behaviorConfig: BehaviorConfig
-                      }
-                    | {
-                        type: 'remove behavior'
-                        behaviorConfig: BehaviorConfig
-                      }
-                    | {
-                        type: 'blur'
-                        editor: PortableTextSlateEditor
-                      }
-                    | {
-                        type: 'focus'
-                        editor: PortableTextSlateEditor
-                      }
-                    | {
-                        type: 'normalizing'
-                      }
-                    | {
-                        type: 'update selection'
-                        selection: EditorSelection
-                      }
-                    | {
-                        type: 'done normalizing'
-                      }
-                    | {
-                        type: 'done syncing value'
-                      }
-                    | {
-                        type: 'syncing value'
-                      }
-                    | {
-                        type: 'behavior event'
-                        behaviorEvent: BehaviorEvent
-                        editor: PortableTextSlateEditor
-                        nativeEvent?: {
-                          preventDefault: () => void
-                        }
-                      }
-                    | {
-                        type: 'dragstart'
-                        origin: Pick<EventPosition, 'selection'>
-                        ghost?: HTMLElement
-                      }
-                    | {
-                        type: 'dragend'
-                      }
-                    | {
-                        type: 'drop'
-                      },
-                    undefined,
-                    never,
-                    never,
-                    never,
-                    never,
-                    never
-                  >,
-                ]
-              }
-            }
-            readonly initial: 'idle'
-            readonly states: {
-              readonly 'idle': {
-                readonly entry: readonly [() => void]
-                readonly exit: readonly [() => void]
-                readonly on: {
-                  readonly dragstart: {
-                    readonly actions: readonly [
-                      ActionFunction<
-                        {
-                          behaviors: Set<BehaviorConfig>
-                          converters: Set<Converter>
-                          getLegacySchema: () => PortableTextMemberSchemaTypes
-                          keyGenerator: () => string
-                          pendingEvents: Array<
-                            InternalPatchEvent | MutationEvent
-                          >
-                          pendingIncomingPatchesEvents: Array<PatchesEvent>
-                          schema: EditorSchema
-                          initialReadOnly: boolean
-                          maxBlocks: number | undefined
-                          selection: EditorSelection
-                          initialValue: Array<PortableTextBlock> | undefined
-                          internalDrag?: {
-                            ghost?: HTMLElement
-                            origin: Pick<EventPosition, 'selection'>
-                          }
-                          slateEditor?: PortableTextSlateEditor
-                        },
-                        {
-                          type: 'dragstart'
-                          origin: Pick<EventPosition, 'selection'>
-                          ghost?: HTMLElement
-                        },
-                        | InternalPatchEvent
-                        | MutationEvent
-                        | PatchesEvent
-                        | {
-                            type: 'update readOnly'
-                            readOnly: boolean
-                          }
-                        | {
-                            type: 'update maxBlocks'
-                            maxBlocks: number | undefined
-                          }
-                        | {
-                            type: 'add behavior'
-                            behaviorConfig: BehaviorConfig
-                          }
-                        | {
-                            type: 'remove behavior'
-                            behaviorConfig: BehaviorConfig
-                          }
-                        | {
-                            type: 'blur'
-                            editor: PortableTextSlateEditor
-                          }
-                        | {
-                            type: 'focus'
-                            editor: PortableTextSlateEditor
-                          }
-                        | {
-                            type: 'normalizing'
-                          }
-                        | {
-                            type: 'update selection'
-                            selection: EditorSelection
-                          }
-                        | {
-                            type: 'done normalizing'
-                          }
-                        | {
-                            type: 'done syncing value'
-                          }
-                        | {
-                            type: 'syncing value'
-                          }
-                        | {
-                            type: 'behavior event'
-                            behaviorEvent: BehaviorEvent
-                            editor: PortableTextSlateEditor
-                            nativeEvent?: {
-                              preventDefault: () => void
-                            }
-                          }
-                        | {
-                            type: 'dragstart'
-                            origin: Pick<EventPosition, 'selection'>
-                            ghost?: HTMLElement
-                          }
-                        | {
-                            type: 'dragend'
-                          }
-                        | {
-                            type: 'drop'
-                          },
-                        undefined,
-                        never,
-                        never,
-                        never,
-                        never,
-                        never
-                      >,
-                    ]
-                    readonly target: 'dragging internally'
-                  }
-                }
-              }
-              readonly 'focusing': {
-                readonly initial: 'checking if busy'
-                readonly states: {
-                  readonly 'checking if busy': {
-                    readonly entry: readonly [() => void]
-                    readonly exit: readonly [() => void]
-                    readonly always: readonly [
-                      {
-                        readonly guard: 'slate is busy'
-                        readonly target: 'busy'
-                      },
-                      {
-                        readonly target: '#editor.edit mode.editable.idle'
-                        readonly actions: readonly ['handle focus']
-                      },
-                    ]
-                  }
-                  readonly 'busy': {
-                    readonly entry: readonly [() => void]
-                    readonly exit: readonly [() => void]
-                    readonly after: {
-                      readonly 10: {
-                        readonly target: 'checking if busy'
-                      }
-                    }
-                  }
-                }
-              }
-              readonly 'dragging internally': {
-                readonly entry: readonly [() => void]
-                readonly exit: readonly [
-                  () => void,
-                  ({
-                    context,
-                  }: ActionArgs<
-                    {
-                      behaviors: Set<BehaviorConfig>
-                      converters: Set<Converter>
-                      getLegacySchema: () => PortableTextMemberSchemaTypes
-                      keyGenerator: () => string
-                      pendingEvents: Array<InternalPatchEvent | MutationEvent>
-                      pendingIncomingPatchesEvents: Array<PatchesEvent>
-                      schema: EditorSchema
-                      initialReadOnly: boolean
-                      maxBlocks: number | undefined
-                      selection: EditorSelection
-                      initialValue: Array<PortableTextBlock> | undefined
-                      internalDrag?: {
-                        ghost?: HTMLElement
-                        origin: Pick<EventPosition, 'selection'>
-                      }
-                      slateEditor?: PortableTextSlateEditor
-                    },
-                    | InternalPatchEvent
-                    | MutationEvent
-                    | PatchesEvent
-                    | {
-                        type: 'update readOnly'
-                        readOnly: boolean
-                      }
-                    | {
-                        type: 'update maxBlocks'
-                        maxBlocks: number | undefined
-                      }
-                    | {
-                        type: 'add behavior'
-                        behaviorConfig: BehaviorConfig
-                      }
-                    | {
-                        type: 'remove behavior'
-                        behaviorConfig: BehaviorConfig
-                      }
-                    | {
-                        type: 'blur'
-                        editor: PortableTextSlateEditor
-                      }
-                    | {
-                        type: 'focus'
-                        editor: PortableTextSlateEditor
-                      }
-                    | {
-                        type: 'normalizing'
-                      }
-                    | {
-                        type: 'update selection'
-                        selection: EditorSelection
-                      }
-                    | {
-                        type: 'done normalizing'
-                      }
-                    | {
-                        type: 'done syncing value'
-                      }
-                    | {
-                        type: 'syncing value'
-                      }
-                    | {
-                        type: 'behavior event'
-                        behaviorEvent: BehaviorEvent
-                        editor: PortableTextSlateEditor
-                        nativeEvent?: {
-                          preventDefault: () => void
-                        }
-                      }
-                    | {
-                        type: 'dragstart'
-                        origin: Pick<EventPosition, 'selection'>
-                        ghost?: HTMLElement
-                      }
-                    | {
-                        type: 'dragend'
-                      }
-                    | {
-                        type: 'drop'
-                      },
-                    | InternalPatchEvent
-                    | MutationEvent
-                    | PatchesEvent
-                    | {
-                        type: 'update readOnly'
-                        readOnly: boolean
-                      }
-                    | {
-                        type: 'update maxBlocks'
-                        maxBlocks: number | undefined
-                      }
-                    | {
-                        type: 'add behavior'
-                        behaviorConfig: BehaviorConfig
-                      }
-                    | {
-                        type: 'remove behavior'
-                        behaviorConfig: BehaviorConfig
-                      }
-                    | {
-                        type: 'blur'
-                        editor: PortableTextSlateEditor
-                      }
-                    | {
-                        type: 'focus'
-                        editor: PortableTextSlateEditor
-                      }
-                    | {
-                        type: 'normalizing'
-                      }
-                    | {
-                        type: 'update selection'
-                        selection: EditorSelection
-                      }
-                    | {
-                        type: 'done normalizing'
-                      }
-                    | {
-                        type: 'done syncing value'
-                      }
-                    | {
-                        type: 'syncing value'
-                      }
-                    | {
-                        type: 'behavior event'
-                        behaviorEvent: BehaviorEvent
-                        editor: PortableTextSlateEditor
-                        nativeEvent?: {
-                          preventDefault: () => void
-                        }
-                      }
-                    | {
-                        type: 'dragstart'
-                        origin: Pick<EventPosition, 'selection'>
-                        ghost?: HTMLElement
-                      }
-                    | {
-                        type: 'dragend'
-                      }
-                    | {
-                        type: 'drop'
-                      }
-                  >) => void,
-                  ActionFunction<
-                    {
-                      behaviors: Set<BehaviorConfig>
-                      converters: Set<Converter>
-                      getLegacySchema: () => PortableTextMemberSchemaTypes
-                      keyGenerator: () => string
-                      pendingEvents: Array<InternalPatchEvent | MutationEvent>
-                      pendingIncomingPatchesEvents: Array<PatchesEvent>
-                      schema: EditorSchema
-                      initialReadOnly: boolean
-                      maxBlocks: number | undefined
-                      selection: EditorSelection
-                      initialValue: Array<PortableTextBlock> | undefined
-                      internalDrag?: {
-                        ghost?: HTMLElement
-                        origin: Pick<EventPosition, 'selection'>
-                      }
-                      slateEditor?: PortableTextSlateEditor
-                    },
-                    | InternalPatchEvent
-                    | MutationEvent
-                    | PatchesEvent
-                    | {
-                        type: 'update readOnly'
-                        readOnly: boolean
-                      }
-                    | {
-                        type: 'update maxBlocks'
-                        maxBlocks: number | undefined
-                      }
-                    | {
-                        type: 'add behavior'
-                        behaviorConfig: BehaviorConfig
-                      }
-                    | {
-                        type: 'remove behavior'
-                        behaviorConfig: BehaviorConfig
-                      }
-                    | {
-                        type: 'blur'
-                        editor: PortableTextSlateEditor
-                      }
-                    | {
-                        type: 'focus'
-                        editor: PortableTextSlateEditor
-                      }
-                    | {
-                        type: 'normalizing'
-                      }
-                    | {
-                        type: 'update selection'
-                        selection: EditorSelection
-                      }
-                    | {
-                        type: 'done normalizing'
-                      }
-                    | {
-                        type: 'done syncing value'
-                      }
-                    | {
-                        type: 'syncing value'
-                      }
-                    | {
-                        type: 'behavior event'
-                        behaviorEvent: BehaviorEvent
-                        editor: PortableTextSlateEditor
-                        nativeEvent?: {
-                          preventDefault: () => void
-                        }
-                      }
-                    | {
-                        type: 'dragstart'
-                        origin: Pick<EventPosition, 'selection'>
-                        ghost?: HTMLElement
-                      }
-                    | {
-                        type: 'dragend'
-                      }
-                    | {
-                        type: 'drop'
-                      },
-                    | InternalPatchEvent
-                    | MutationEvent
-                    | PatchesEvent
-                    | {
-                        type: 'update readOnly'
-                        readOnly: boolean
-                      }
-                    | {
-                        type: 'update maxBlocks'
-                        maxBlocks: number | undefined
-                      }
-                    | {
-                        type: 'add behavior'
-                        behaviorConfig: BehaviorConfig
-                      }
-                    | {
-                        type: 'remove behavior'
-                        behaviorConfig: BehaviorConfig
-                      }
-                    | {
-                        type: 'blur'
-                        editor: PortableTextSlateEditor
-                      }
-                    | {
-                        type: 'focus'
-                        editor: PortableTextSlateEditor
-                      }
-                    | {
-                        type: 'normalizing'
-                      }
-                    | {
-                        type: 'update selection'
-                        selection: EditorSelection
-                      }
-                    | {
-                        type: 'done normalizing'
-                      }
-                    | {
-                        type: 'done syncing value'
-                      }
-                    | {
-                        type: 'syncing value'
-                      }
-                    | {
-                        type: 'behavior event'
-                        behaviorEvent: BehaviorEvent
-                        editor: PortableTextSlateEditor
-                        nativeEvent?: {
-                          preventDefault: () => void
-                        }
-                      }
-                    | {
-                        type: 'dragstart'
-                        origin: Pick<EventPosition, 'selection'>
-                        ghost?: HTMLElement
-                      }
-                    | {
-                        type: 'dragend'
-                      }
-                    | {
-                        type: 'drop'
-                      },
-                    undefined,
-                    never,
-                    never,
-                    never,
-                    never,
-                    never
-                  >,
-                ]
-                readonly tags: readonly ['dragging internally']
-                readonly on: {
-                  readonly dragend: {
-                    readonly target: 'idle'
-                  }
-                  readonly drop: {
-                    readonly target: 'idle'
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      readonly 'setup': {
-        readonly initial: 'setting up'
-        readonly states: {
-          readonly 'setting up': {
-            readonly entry: readonly [() => void]
-            readonly exit: readonly [
-              () => void,
-              'emit ready',
-              'emit pending incoming patches',
-              'clear pending incoming patches',
-            ]
-            readonly on: {
-              readonly 'internal.patch': {
-                readonly actions: 'defer event'
-              }
-              readonly 'mutation': {
-                readonly actions: 'defer event'
-              }
-              readonly 'done syncing value': {
-                readonly target: 'set up'
-              }
-              readonly 'patches': {
-                readonly actions: readonly ['defer incoming patches']
-              }
-            }
-          }
-          readonly 'set up': {
-            readonly type: 'parallel'
-            readonly states: {
-              readonly 'value sync': {
-                readonly initial: 'idle'
-                readonly states: {
-                  readonly 'idle': {
-                    readonly entry: readonly [() => void]
-                    readonly exit: readonly [() => void]
-                    readonly on: {
-                      readonly 'patches': {
-                        readonly actions: readonly [
-                          ActionFunction<
-                            {
-                              behaviors: Set<BehaviorConfig>
-                              converters: Set<Converter>
-                              getLegacySchema: () => PortableTextMemberSchemaTypes
-                              keyGenerator: () => string
-                              pendingEvents: Array<
-                                InternalPatchEvent | MutationEvent
-                              >
-                              pendingIncomingPatchesEvents: Array<PatchesEvent>
-                              schema: EditorSchema
-                              initialReadOnly: boolean
-                              maxBlocks: number | undefined
-                              selection: EditorSelection
-                              initialValue: Array<PortableTextBlock> | undefined
-                              internalDrag?: {
-                                ghost?: HTMLElement
-                                origin: Pick<EventPosition, 'selection'>
-                              }
-                              slateEditor?: PortableTextSlateEditor
-                            },
-                            PatchesEvent,
-                            | InternalPatchEvent
-                            | MutationEvent
-                            | PatchesEvent
-                            | {
-                                type: 'update readOnly'
-                                readOnly: boolean
-                              }
-                            | {
-                                type: 'update maxBlocks'
-                                maxBlocks: number | undefined
-                              }
-                            | {
-                                type: 'add behavior'
-                                behaviorConfig: BehaviorConfig
-                              }
-                            | {
-                                type: 'remove behavior'
-                                behaviorConfig: BehaviorConfig
-                              }
-                            | {
-                                type: 'blur'
-                                editor: PortableTextSlateEditor
-                              }
-                            | {
-                                type: 'focus'
-                                editor: PortableTextSlateEditor
-                              }
-                            | {
-                                type: 'normalizing'
-                              }
-                            | {
-                                type: 'update selection'
-                                selection: EditorSelection
-                              }
-                            | {
-                                type: 'done normalizing'
-                              }
-                            | {
-                                type: 'done syncing value'
-                              }
-                            | {
-                                type: 'syncing value'
-                              }
-                            | {
-                                type: 'behavior event'
-                                behaviorEvent: BehaviorEvent
-                                editor: PortableTextSlateEditor
-                                nativeEvent?: {
-                                  preventDefault: () => void
-                                }
-                              }
-                            | {
-                                type: 'dragstart'
-                                origin: Pick<EventPosition, 'selection'>
-                                ghost?: HTMLElement
-                              }
-                            | {
-                                type: 'dragend'
-                              }
-                            | {
-                                type: 'drop'
-                              },
-                            undefined,
-                            never,
-                            never,
-                            never,
-                            never,
-                            | InternalPatchEvent
-                            | MutationEvent
-                            | PatchesEvent
-                            | {
-                                type: 'blurred'
-                                event: FocusEvent_2<HTMLDivElement, Element>
-                              }
-                            | {
-                                type: 'done loading'
-                              }
-                            | {
-                                type: 'editable'
-                              }
-                            | {
-                                type: 'error'
-                                name: string
-                                description: string
-                                data: unknown
-                              }
-                            | {
-                                type: 'focused'
-                                event: FocusEvent_2<HTMLDivElement, Element>
-                              }
-                            | {
-                                type: 'invalid value'
-                                resolution: InvalidValueResolution | null
-                                value: Array<PortableTextBlock> | undefined
-                              }
-                            | {
-                                type: 'loading'
-                              }
-                            | {
-                                type: 'read only'
-                              }
-                            | {
-                                type: 'ready'
-                              }
-                            | {
-                                type: 'selection'
-                                selection: EditorSelection
-                              }
-                            | {
-                                type: 'value changed'
-                                value: Array<PortableTextBlock> | undefined
-                              }
-                          >,
-                        ]
-                      }
-                      readonly 'syncing value': {
-                        readonly target: 'syncing value'
-                      }
-                    }
-                  }
-                  readonly 'syncing value': {
-                    readonly entry: readonly [() => void]
-                    readonly exit: readonly [
-                      () => void,
-                      'emit pending incoming patches',
-                      'clear pending incoming patches',
-                    ]
-                    readonly on: {
-                      readonly 'patches': {
-                        readonly actions: readonly ['defer incoming patches']
-                      }
-                      readonly 'done syncing value': {
-                        readonly target: 'idle'
-                      }
-                    }
-                  }
-                }
-              }
-              readonly 'writing': {
-                readonly initial: 'pristine'
-                readonly states: {
-                  readonly pristine: {
-                    readonly initial: 'idle'
-                    readonly states: {
-                      readonly idle: {
-                        readonly entry: readonly [() => void]
-                        readonly exit: readonly [() => void]
-                        readonly on: {
-                          readonly 'normalizing': {
-                            readonly target: 'normalizing'
-                          }
-                          readonly 'internal.patch': {
-                            readonly actions: 'defer event'
-                            readonly target: '#editor.setup.set up.writing.dirty'
-                          }
-                          readonly 'mutation': {
-                            readonly actions: 'defer event'
-                            readonly target: '#editor.setup.set up.writing.dirty'
-                          }
-                        }
-                      }
-                      readonly normalizing: {
-                        readonly entry: readonly [() => void]
-                        readonly exit: readonly [() => void]
-                        readonly on: {
-                          readonly 'done normalizing': {
-                            readonly target: 'idle'
-                          }
-                          readonly 'internal.patch': {
-                            readonly actions: 'defer event'
-                          }
-                          readonly 'mutation': {
-                            readonly actions: 'defer event'
-                          }
-                        }
-                      }
-                    }
-                  }
-                  readonly dirty: {
-                    readonly entry: readonly [
-                      () => void,
-                      'emit pending events',
-                      'clear pending events',
-                    ]
-                    readonly exit: readonly [() => void]
-                    readonly on: {
-                      readonly 'internal.patch': {
-                        readonly actions: 'emit patch event'
-                      }
-                      readonly 'mutation': {
-                        readonly actions: 'emit mutation event'
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
->
-
-declare type EditorPriority = {
-  id: string
-  name?: string
-  reference?: {
-    priority: EditorPriority
-    importance: 'higher' | 'lower'
-  }
-}
-
 /**
  * @beta
  */
@@ -2536,12 +674,6 @@ declare type EditorSnapshot = {
   beta: {
     activeAnnotations: Array<string>
     activeDecorators: Array<string>
-    hasTag: HasTag
-    internalDrag:
-      | {
-          origin: Pick<EventPosition, 'selection'>
-        }
-      | undefined
   }
 }
 
@@ -2664,18 +796,6 @@ declare type ExternalEditorEvent =
 declare type ExtractNamespace<TType extends string> =
   TType extends `${infer Namespace}.${string}` ? Namespace : TType
 
-declare type HasTag = ReturnType<EditorActor['getSnapshot']>['hasTag']
-
-declare interface History_2 {
-  redos: HistoryItem[]
-  undos: HistoryItem[]
-}
-
-declare type HistoryItem = {
-  operations: Operation[]
-  timestamp: Date
-}
-
 /**
  * Used to represent native InputEvents that hold a DataTransfer object.
  *
@@ -2696,15 +816,10 @@ declare type InputBehaviorEvent = {
 
 declare type InsertPlacement = 'auto' | 'after' | 'before'
 
-declare type InternalPatchEvent = NamespaceEvent<PatchEvent, 'internal'> & {
-  operationId?: string
-  value: Array<PortableTextBlock>
-}
-
 /**
  * The editor has invalid data in the value that can be resolved by the user
  * @beta */
-declare type InvalidValueResolution_2 = {
+declare type InvalidValueResolution = {
   autoResolve?: boolean
   patches: Patch[]
   description: string
@@ -2827,11 +942,6 @@ export declare type MarkdownPluginConfig = MarkdownBehaviorsConfig & {
   }) => string | undefined
 }
 
-declare type MarkState = {
-  state: 'changed' | 'unchanged'
-  marks: Array<string>
-}
-
 declare type MIMEType = `${string}/${string}`
 
 declare type MouseBehaviorEvent = {
@@ -2858,19 +968,6 @@ declare type NamespacedBehaviorEventType<
   ? BehaviorEvent['type']
   : Extract<BehaviorEvent['type'], TNamespace | `${TNamespace}.${string}`>
 
-declare type NamespaceEvent<
-  TEvent,
-  TNamespace extends string,
-> = TEvent extends {
-  type: infer TEventType
-}
-  ? {
-      [K in keyof TEvent]: K extends 'type'
-        ? `${TNamespace}.${TEventType & string}`
-        : TEvent[K]
-    }
-  : never
-
 /**
  * @beta
  */
@@ -2945,57 +1042,6 @@ declare type PickFromUnion<
   TPickedTags extends TUnion[TTagKey],
 > = TUnion extends Record<TTagKey, TPickedTags> ? TUnion : never
 
-/** @beta */
-declare type PortableTextMemberSchemaTypes = {
-  annotations: (ObjectSchemaType & {
-    i18nTitleKey?: string
-  })[]
-  block: ObjectSchemaType
-  blockObjects: ObjectSchemaType[]
-  decorators: BlockDecoratorDefinition[]
-  inlineObjects: ObjectSchemaType[]
-  portableText: ArraySchemaType<PortableTextBlock>
-  span: ObjectSchemaType
-  styles: BlockStyleDefinition[]
-  lists: BlockListDefinition[]
-}
-
-declare interface PortableTextSlateEditor extends ReactEditor {
-  _key: 'editor'
-  _type: 'editor'
-  createPlaceholderBlock: () => Descendant
-  editable: EditableAPI
-  history: History_2
-  insertPortableTextData: (data: DataTransfer) => boolean
-  insertTextOrHTMLData: (data: DataTransfer) => boolean
-  isTextBlock: (value: unknown) => value is PortableTextTextBlock
-  isTextSpan: (value: unknown) => value is PortableTextSpan
-  isListBlock: (value: unknown) => value is PortableTextListBlock
-  value: Array<PortableTextBlock>
-  decoratorState: Record<string, boolean | undefined>
-  markState: MarkState | undefined
-  /**
-   * Use hotkeys
-   */
-  pteWithHotKeys: (event: KeyboardEvent_2<HTMLDivElement>) => void
-  /**
-   * Helper function that creates a text block
-   */
-  pteCreateTextBlock: (options: {
-    decorators: Array<string>
-    listItem?: string
-    level?: number
-  }) => Descendant
-  /**
-   * Undo
-   */
-  undo: () => void
-  /**
-   * Redo
-   */
-  redo: () => void
-}
-
 /**************************************
  * Resolve behavior event
  **************************************/