@portabletext/toolbar 8.0.43 → 8.0.44

package/dist/index.d.ts

@@ -1,448 +1,93 @@
-import {AnnotationDefinition} from '@portabletext/editor'
-import {AnnotationPath} from '@portabletext/editor'
-import {AnnotationSchemaType} from '@portabletext/editor'
-import {ApplicableSchema} from '@portabletext/editor/selectors'
-import {BlockObjectSchemaType} from '@portabletext/editor'
-import {BlockPath} from '@portabletext/editor'
-import {ChildPath} from '@portabletext/editor'
-import {DecoratorDefinition} from '@portabletext/editor'
-import {DecoratorSchemaType} from '@portabletext/editor'
-import {InlineObjectSchemaType} from '@portabletext/editor'
-import {InsertPlacement} from '@portabletext/editor/behaviors'
-import type {KeyboardShortcut} from '@portabletext/keyboard-shortcuts'
-import {ListSchemaType} from '@portabletext/editor'
-import {PortableTextObject} from '@portabletext/editor'
-import type {RefObject} from 'react'
-import {StyleSchemaType} from '@portabletext/editor'
-
-declare type ActiveContext = {
-  annotations: Array<{
-    value: PortableTextObject
-    schemaType: ToolbarAnnotationSchemaType
-    at: AnnotationPath
-  }>
-  elementRef: RefObject<Element | null>
-}
-
-declare type ActiveContext_2 = {
-  blockObjects: Array<{
-    value: PortableTextObject
-    schemaType: ToolbarBlockObjectSchemaType
-    at: BlockPath
-  }>
-  elementRef: RefObject<Element | null>
-}
-
-declare type ActiveContext_3 = {
-  inlineObjects: Array<{
-    value: PortableTextObject
-    schemaType: ToolbarInlineObjectSchemaType
-    at: ChildPath
-  }>
-  elementRef: RefObject<Element | null>
-}
-
-/**
- * @beta
- */
-export declare type AnnotationButton = {
-  snapshot: {
-    matches: (
-      state:
-        | 'disabled'
-        | 'enabled'
-        | {
-            disabled: 'inactive'
-          }
-        | {
-            disabled: 'active'
-          }
-        | {
-            enabled: 'inactive'
-          }
-        | {
-            enabled: {
-              inactive: 'idle'
-            }
-          }
-        | {
-            enabled: {
-              inactive: 'showing dialog'
-            }
-          }
-        | {
-            enabled: 'active'
-          },
-    ) => boolean
-  }
-  send: (event: AnnotationButtonEvent) => void
-}
-
-/**
- * @beta
- */
-export declare type AnnotationButtonEvent =
-  | {
-      type: 'close dialog'
-    }
-  | {
-      type: 'open dialog'
-    }
-  | {
-      type: 'add'
-      annotation: {
-        value: Record<string, unknown>
-      }
-    }
-  | {
-      type: 'remove'
-    }
-
-/**
- * @beta
- */
-export declare type AnnotationPopover = {
-  snapshot: {
-    context: ActiveContext
-    matches: (
-      state:
-        | 'disabled'
-        | 'enabled'
-        | {
-            enabled: 'inactive' | 'active'
-          },
-    ) => boolean
-  }
-  send: (event: AnnotationPopoverEvent) => void
-}
-
-/**
- * @beta
- */
-export declare type AnnotationPopoverEvent =
-  | {
-      type: 'remove'
-      schemaType: AnnotationSchemaType
-    }
-  | {
-      type: 'edit'
-      at: AnnotationPath
-      props: {
-        [key: string]: unknown
-      }
-    }
-  | {
-      type: 'close'
-    }
-
-export {ApplicableSchema}
-
-/**
- * @beta
- */
-export declare type BlockObjectButton = {
-  snapshot: {
-    matches: (
-      state:
-        | 'disabled'
-        | 'enabled'
-        | {
-            enabled: 'idle'
-          }
-        | {
-            enabled: 'showing dialog'
-          },
-    ) => boolean
-  }
-  send: (event: BlockObjectButtonEvent) => void
-}
-
-/**
- * @beta
- */
-export declare type BlockObjectButtonEvent =
-  | {
-      type: 'close dialog'
-    }
-  | {
-      type: 'open dialog'
-    }
-  | {
-      type: 'insert'
-      value: {
-        [key: string]: unknown
-      }
-      placement: InsertPlacement | undefined
-    }
-
-/**
- * @beta
- */
-export declare type BlockObjectPopover = {
-  snapshot: {
-    context: ActiveContext_2
-    matches: (
-      state:
-        | 'disabled'
-        | 'enabled'
-        | {
-            enabled: 'inactive' | 'active'
-          },
-    ) => boolean
-  }
-  send: (event: BlockObjectPopoverEvent) => void
-}
-
-/**
- * @beta
- */
-export declare type BlockObjectPopoverEvent =
-  | {
-      type: 'remove'
-      at: BlockPath
-    }
-  | {
-      type: 'edit'
-      at: BlockPath
-      props: {
-        [key: string]: unknown
-      }
-    }
-  | {
-      type: 'close'
-    }
-
-/**
- * @beta
- */
-export declare type DecoratorButton = {
-  snapshot: {
-    matches: (
-      state:
-        | 'disabled'
-        | 'enabled'
-        | {
-            disabled: 'inactive'
-          }
-        | {
-            disabled: 'active'
-          }
-        | {
-            enabled: 'inactive'
-          }
-        | {
-            enabled: 'active'
-          },
-    ) => boolean
-  }
-  send: (event: DecoratorButtonEvent) => void
-}
-
-/**
- * @beta
- */
-export declare type DecoratorButtonEvent = {
-  type: 'toggle'
-}
-
+import { AnnotationDefinition, AnnotationPath, AnnotationSchemaType, BlockObjectSchemaType, BlockPath, ChildPath, DecoratorDefinition, DecoratorSchemaType, InlineObjectSchemaType, ListSchemaType, PortableTextObject, StyleSchemaType } from "@portabletext/editor";
+import { ApplicableSchema } from "@portabletext/editor/selectors";
+import { InsertPlacement } from "@portabletext/editor/behaviors";
+import { RefObject } from "react";
+import { KeyboardShortcut } from "@portabletext/keyboard-shortcuts";
 /**
  * @beta
+ *
+ * React hook that subscribes to {@link getApplicableSchema} for the active
+ * editor and returns a stable reference across editor ticks while the
+ * applicable set is unchanged.
+ *
+ * Pair with {@link useToolbarSchema} to render a static toolbar whose
+ * buttons stay stable across selection moves and gate their enabled state
+ * on whether the corresponding name is in the relevant set.
  */
-export declare type ExtendAnnotationSchemaType = (
-  annotation: AnnotationSchemaType,
-) => ToolbarAnnotationSchemaType
-
+declare function useApplicableSchema(): ApplicableSchema;
 /**
  * @beta
  */
-export declare type ExtendBlockObjectSchemaType = (
-  blockObject: BlockObjectSchemaType,
-) => ToolbarBlockObjectSchemaType
-
+type ExtendDecoratorSchemaType = (decorator: DecoratorSchemaType) => ToolbarDecoratorSchemaType;
 /**
  * @beta
  */
-export declare type ExtendDecoratorSchemaType = (
-  decorator: DecoratorSchemaType,
-) => ToolbarDecoratorSchemaType
-
+type ExtendAnnotationSchemaType = (annotation: AnnotationSchemaType) => ToolbarAnnotationSchemaType;
 /**
  * @beta
  */
-export declare type ExtendInlineObjectSchemaType = (
-  inlineObject: InlineObjectSchemaType,
-) => ToolbarInlineObjectSchemaType
-
+type ExtendListSchemaType = (list: ListSchemaType) => ToolbarListSchemaType;
 /**
  * @beta
  */
-export declare type ExtendListSchemaType = (
-  list: ListSchemaType,
-) => ToolbarListSchemaType
-
+type ExtendBlockObjectSchemaType = (blockObject: BlockObjectSchemaType) => ToolbarBlockObjectSchemaType;
 /**
  * @beta
  */
-export declare type ExtendStyleSchemaType = (
-  style: StyleSchemaType,
-) => ToolbarStyleSchemaType
-
+type ExtendInlineObjectSchemaType = (inlineObject: InlineObjectSchemaType) => ToolbarInlineObjectSchemaType;
 /**
  * @beta
  */
-export declare type HistoryButtons = {
-  snapshot: {
-    matches: (state: 'disabled' | 'enabled') => boolean
-  }
-  send: (event: HistoryButtonsEvent) => void
-}
-
+type ExtendStyleSchemaType = (style: StyleSchemaType) => ToolbarStyleSchemaType;
 /**
  * @beta
+ *
+ * Resolve the editor's full toolbar schema. Returns the union of every
+ * decorator, annotation, list, style, block object and inline object declared
+ * anywhere in the editor's schema graph that is reachable from a position
+ * where text is edited - the root schema merged with the sub-schema of every
+ * registered container whose field accepts text blocks. Useful for rendering
+ * a static toolbar whose buttons stay stable across selection moves.
+ *
+ * Re-renders only when the schema graph or the extension callbacks change.
+ * Pair with {@link useApplicableSchema} to determine which entries are
+ * applicable at the current selection (which buttons should be enabled vs.
+ * disabled).
  */
-export declare type HistoryButtonsEvent =
-  | {
-      type: 'history.undo'
-    }
-  | {
-      type: 'history.redo'
-    }
-
+declare function useToolbarSchema(props: {
+  extendDecorator?: ExtendDecoratorSchemaType;
+  extendAnnotation?: ExtendAnnotationSchemaType;
+  extendList?: ExtendListSchemaType;
+  extendBlockObject?: ExtendBlockObjectSchemaType;
+  extendInlineObject?: ExtendInlineObjectSchemaType;
+  extendStyle?: ExtendStyleSchemaType;
+}): ToolbarSchema;
 /**
  * @beta
  */
-export declare type InlineObjectButton = {
-  snapshot: {
-    matches: (
-      state:
-        | 'disabled'
-        | 'enabled'
-        | {
-            enabled: 'idle'
-          }
-        | {
-            enabled: 'showing dialog'
-          },
-    ) => boolean
-  }
-  send: (event: InlineObjectButtonEvent) => void
-}
-
-/**
- * @beta
- */
-export declare type InlineObjectButtonEvent =
-  | {
-      type: 'close dialog'
-    }
-  | {
-      type: 'open dialog'
-    }
-  | {
-      type: 'insert'
-      value: {
-        [key: string]: unknown
-      }
-    }
-
-/**
- * @beta
- */
-export declare type InlineObjectPopover = {
-  snapshot: {
-    context: ActiveContext_3
-    matches: (
-      state:
-        | 'disabled'
-        | 'enabled'
-        | {
-            enabled: 'inactive' | 'active'
-          },
-    ) => boolean
-  }
-  send: (event: InlineObjectPopoverEvent) => void
-}
-
-/**
- * @beta
- */
-export declare type InlineObjectPopoverEvent =
-  | {
-      type: 'remove'
-      at: ChildPath
-    }
-  | {
-      type: 'edit'
-      at: ChildPath
-      props: {
-        [key: string]: unknown
-      }
-    }
-  | {
-      type: 'close'
-    }
-
-/**
- * @beta
- */
-export declare type ListButton = {
-  snapshot: {
-    matches: (
-      state:
-        | 'disabled'
-        | 'enabled'
-        | {
-            disabled: 'inactive'
-          }
-        | {
-            disabled: 'active'
-          }
-        | {
-            enabled: 'inactive'
-          }
-        | {
-            enabled: 'active'
-          },
-    ) => boolean
-  }
-  send: (event: ListButtonEvent) => void
-}
-
-/**
- * @beta
- */
-export declare type ListButtonEvent = {
-  type: 'toggle'
-}
-
-/**
- * @beta
- */
-export declare type StyleSelector = {
-  snapshot: {
-    matches: (state: 'disabled' | 'enabled') => boolean
-    context: {
-      activeStyle: StyleSchemaType['name'] | undefined
-    }
-  }
-  send: (event: StyleSelectorEvent) => void
-}
-
+type ToolbarSchema = {
+  decorators: ReadonlyArray<ToolbarDecoratorSchemaType>;
+  annotations: ReadonlyArray<ToolbarAnnotationSchemaType>;
+  lists: ReadonlyArray<ToolbarListSchemaType>;
+  blockObjects: ReadonlyArray<ToolbarBlockObjectSchemaType>;
+  inlineObjects: ReadonlyArray<ToolbarInlineObjectSchemaType>;
+  styles: ReadonlyArray<ToolbarStyleSchemaType>;
+};
 /**
  * @beta
  */
-export declare type StyleSelectorEvent = {
-  type: 'toggle'
-  style: StyleSchemaType['name']
-}
-
+type ToolbarDecoratorSchemaType = DecoratorSchemaType & {
+  icon?: React.ComponentType;
+  shortcut?: KeyboardShortcut;
+  mutuallyExclusive?: ReadonlyArray<DecoratorDefinition['name']>;
+};
 /**
  * @beta
  */
-export declare type ToolbarAnnotationSchemaType = AnnotationSchemaType & {
-  icon?: React.ComponentType
-  defaultValues?: Record<string, unknown>
-  shortcut?: KeyboardShortcut
+type ToolbarAnnotationSchemaType = AnnotationSchemaType & {
+  icon?: React.ComponentType;
+  defaultValues?: Record<string, unknown>;
+  shortcut?: KeyboardShortcut;
   /**
    * The annotations this annotation cannot coexist with. The list
    * replaces the default rule that an annotation is mutually exclusive
@@ -455,63 +100,77 @@ export declare type ToolbarAnnotationSchemaType = AnnotationSchemaType & {
    * - `['other']`: exclusive with exactly the listed annotations.
    *   Include the annotation's own name to keep self-exclusivity.
    */
-  mutuallyExclusive?: ReadonlyArray<AnnotationDefinition['name']>
-}
-
+  mutuallyExclusive?: ReadonlyArray<AnnotationDefinition['name']>;
+};
 /**
  * @beta
  */
-export declare type ToolbarBlockObjectSchemaType = BlockObjectSchemaType & {
-  icon?: React.ComponentType
-  defaultValues?: Record<string, unknown>
-  shortcut?: KeyboardShortcut
-}
-
+type ToolbarListSchemaType = ListSchemaType & {
+  icon?: React.ComponentType;
+};
 /**
  * @beta
  */
-export declare type ToolbarDecoratorSchemaType = DecoratorSchemaType & {
-  icon?: React.ComponentType
-  shortcut?: KeyboardShortcut
-  mutuallyExclusive?: ReadonlyArray<DecoratorDefinition['name']>
-}
-
+type ToolbarBlockObjectSchemaType = BlockObjectSchemaType & {
+  icon?: React.ComponentType;
+  defaultValues?: Record<string, unknown>;
+  shortcut?: KeyboardShortcut;
+};
 /**
  * @beta
  */
-export declare type ToolbarInlineObjectSchemaType = InlineObjectSchemaType & {
-  icon?: React.ComponentType
-  defaultValues?: Record<string, unknown>
-  shortcut?: KeyboardShortcut
-}
-
+type ToolbarInlineObjectSchemaType = InlineObjectSchemaType & {
+  icon?: React.ComponentType;
+  defaultValues?: Record<string, unknown>;
+  shortcut?: KeyboardShortcut;
+};
 /**
  * @beta
  */
-export declare type ToolbarListSchemaType = ListSchemaType & {
-  icon?: React.ComponentType
-}
-
+type ToolbarStyleSchemaType = StyleSchemaType & {
+  icon?: React.ComponentType;
+  shortcut?: KeyboardShortcut;
+};
 /**
  * @beta
  */
-export declare type ToolbarSchema = {
-  decorators: ReadonlyArray<ToolbarDecoratorSchemaType>
-  annotations: ReadonlyArray<ToolbarAnnotationSchemaType>
-  lists: ReadonlyArray<ToolbarListSchemaType>
-  blockObjects: ReadonlyArray<ToolbarBlockObjectSchemaType>
-  inlineObjects: ReadonlyArray<ToolbarInlineObjectSchemaType>
-  styles: ReadonlyArray<ToolbarStyleSchemaType>
-}
-
+type AnnotationButtonEvent = {
+  type: 'close dialog';
+} | {
+  type: 'open dialog';
+} | {
+  type: 'add';
+  annotation: {
+    value: Record<string, unknown>;
+  };
+} | {
+  type: 'remove';
+};
 /**
  * @beta
  */
-export declare type ToolbarStyleSchemaType = StyleSchemaType & {
-  icon?: React.ComponentType
-  shortcut?: KeyboardShortcut
-}
-
+type AnnotationButton = {
+  snapshot: {
+    matches: (state: 'disabled' | 'enabled' | {
+      disabled: 'inactive';
+    } | {
+      disabled: 'active';
+    } | {
+      enabled: 'inactive';
+    } | {
+      enabled: {
+        inactive: 'idle';
+      };
+    } | {
+      enabled: {
+        inactive: 'showing dialog';
+      };
+    } | {
+      enabled: 'active';
+    }) => boolean;
+  };
+  send: (event: AnnotationButtonEvent) => void;
+};
 /**
  * @beta
  * Manages the state, keyboard shortcut and available events for an annotation
@@ -520,31 +179,78 @@ export declare type ToolbarStyleSchemaType = StyleSchemaType & {
  * Note: This hook assumes that the button triggers a dialog for inputting
  * the annotation value.
  */
-export declare function useAnnotationButton(props: {
-  schemaType: ToolbarAnnotationSchemaType
-}): AnnotationButton
-
+declare function useAnnotationButton(props: {
+  schemaType: ToolbarAnnotationSchemaType;
+}): AnnotationButton;
+type ActiveContext$2 = {
+  annotations: Array<{
+    value: PortableTextObject;
+    schemaType: ToolbarAnnotationSchemaType;
+    at: AnnotationPath;
+  }>;
+  elementRef: RefObject<Element | null>;
+};
+/**
+ * @beta
+ */
+type AnnotationPopoverEvent = {
+  type: 'remove';
+  schemaType: AnnotationSchemaType;
+} | {
+  type: 'edit';
+  at: AnnotationPath;
+  props: {
+    [key: string]: unknown;
+  };
+} | {
+  type: 'close';
+};
+/**
+ * @beta
+ */
+type AnnotationPopover = {
+  snapshot: {
+    context: ActiveContext$2;
+    matches: (state: 'disabled' | 'enabled' | {
+      enabled: 'inactive' | 'active';
+    }) => boolean;
+  };
+  send: (event: AnnotationPopoverEvent) => void;
+};
 /**
  * @beta
  * Manages the state and available events for an annotation popover.
  */
-export declare function useAnnotationPopover(props: {
-  schemaTypes: ReadonlyArray<ToolbarAnnotationSchemaType>
-}): AnnotationPopover
-
+declare function useAnnotationPopover(props: {
+  schemaTypes: ReadonlyArray<ToolbarAnnotationSchemaType>;
+}): AnnotationPopover;
 /**
  * @beta
- *
- * React hook that subscribes to {@link getApplicableSchema} for the active
- * editor and returns a stable reference across editor ticks while the
- * applicable set is unchanged.
- *
- * Pair with {@link useToolbarSchema} to render a static toolbar whose
- * buttons stay stable across selection moves and gate their enabled state
- * on whether the corresponding name is in the relevant set.
  */
-export declare function useApplicableSchema(): ApplicableSchema
-
+type BlockObjectButtonEvent = {
+  type: 'close dialog';
+} | {
+  type: 'open dialog';
+} | {
+  type: 'insert';
+  value: {
+    [key: string]: unknown;
+  };
+  placement: InsertPlacement | undefined;
+};
+/**
+ * @beta
+ */
+type BlockObjectButton = {
+  snapshot: {
+    matches: (state: 'disabled' | 'enabled' | {
+      enabled: 'idle';
+    } | {
+      enabled: 'showing dialog';
+    }) => boolean;
+  };
+  send: (event: BlockObjectButtonEvent) => void;
+};
 /**
  * @beta
  * Manages the state, keyboard shortcut and available events for a block
@@ -553,32 +259,129 @@ export declare function useApplicableSchema(): ApplicableSchema
  * Note: This hook assumes that the button triggers a dialog for inputting
  * the block object value.
  */
-export declare function useBlockObjectButton(props: {
-  schemaType: ToolbarBlockObjectSchemaType
-}): BlockObjectButton
-
+declare function useBlockObjectButton(props: {
+  schemaType: ToolbarBlockObjectSchemaType;
+}): BlockObjectButton;
+type ActiveContext$1 = {
+  blockObjects: Array<{
+    value: PortableTextObject;
+    schemaType: ToolbarBlockObjectSchemaType;
+    at: BlockPath;
+  }>;
+  elementRef: RefObject<Element | null>;
+};
+/**
+ * @beta
+ */
+type BlockObjectPopoverEvent = {
+  type: 'remove';
+  at: BlockPath;
+} | {
+  type: 'edit';
+  at: BlockPath;
+  props: {
+    [key: string]: unknown;
+  };
+} | {
+  type: 'close';
+};
+/**
+ * @beta
+ */
+type BlockObjectPopover = {
+  snapshot: {
+    context: ActiveContext$1;
+    matches: (state: 'disabled' | 'enabled' | {
+      enabled: 'inactive' | 'active';
+    }) => boolean;
+  };
+  send: (event: BlockObjectPopoverEvent) => void;
+};
 /**
  * @beta
  * Manages the state and available events for a block object popover.
  */
-export declare function useBlockObjectPopover(props: {
-  schemaTypes: ReadonlyArray<ToolbarBlockObjectSchemaType>
-}): BlockObjectPopover
-
+declare function useBlockObjectPopover(props: {
+  schemaTypes: ReadonlyArray<ToolbarBlockObjectSchemaType>;
+}): BlockObjectPopover;
+/**
+ * @beta
+ */
+type DecoratorButtonEvent = {
+  type: 'toggle';
+};
+/**
+ * @beta
+ */
+type DecoratorButton = {
+  snapshot: {
+    matches: (state: 'disabled' | 'enabled' | {
+      disabled: 'inactive';
+    } | {
+      disabled: 'active';
+    } | {
+      enabled: 'inactive';
+    } | {
+      enabled: 'active';
+    }) => boolean;
+  };
+  send: (event: DecoratorButtonEvent) => void;
+};
 /**
  * @beta
  * Manages the state, keyboard shortcuts and available events for a decorator
  * button and sets up mutually exclusive decorator behaviors.
  */
-export declare function useDecoratorButton(props: {
-  schemaType: ToolbarDecoratorSchemaType
-}): DecoratorButton
-
+declare function useDecoratorButton(props: {
+  schemaType: ToolbarDecoratorSchemaType;
+}): DecoratorButton;
+/**
+ * @beta
+ */
+type HistoryButtonsEvent = {
+  type: 'history.undo';
+} | {
+  type: 'history.redo';
+};
 /**
  * @beta
  */
-export declare function useHistoryButtons(): HistoryButtons
-
+type HistoryButtons = {
+  snapshot: {
+    matches: (state: 'disabled' | 'enabled') => boolean;
+  };
+  send: (event: HistoryButtonsEvent) => void;
+};
+/**
+ * @beta
+ */
+declare function useHistoryButtons(): HistoryButtons;
+/**
+ * @beta
+ */
+type InlineObjectButtonEvent = {
+  type: 'close dialog';
+} | {
+  type: 'open dialog';
+} | {
+  type: 'insert';
+  value: {
+    [key: string]: unknown;
+  };
+};
+/**
+ * @beta
+ */
+type InlineObjectButton = {
+  snapshot: {
+    matches: (state: 'disabled' | 'enabled' | {
+      enabled: 'idle';
+    } | {
+      enabled: 'showing dialog';
+    }) => boolean;
+  };
+  send: (event: InlineObjectButtonEvent) => void;
+};
 /**
  * @beta
  * Manages the state, keyboard shortcut and available events for an inline
@@ -587,57 +390,107 @@ export declare function useHistoryButtons(): HistoryButtons
  * Note: This hook assumes that the button triggers a dialog for inputting
  * the inline object value.
  */
-export declare function useInlineObjectButton(props: {
-  schemaType: ToolbarInlineObjectSchemaType
-}): InlineObjectButton
-
+declare function useInlineObjectButton(props: {
+  schemaType: ToolbarInlineObjectSchemaType;
+}): InlineObjectButton;
+type ActiveContext = {
+  inlineObjects: Array<{
+    value: PortableTextObject;
+    schemaType: ToolbarInlineObjectSchemaType;
+    at: ChildPath;
+  }>;
+  elementRef: RefObject<Element | null>;
+};
+/**
+ * @beta
+ */
+type InlineObjectPopoverEvent = {
+  type: 'remove';
+  at: ChildPath;
+} | {
+  type: 'edit';
+  at: ChildPath;
+  props: {
+    [key: string]: unknown;
+  };
+} | {
+  type: 'close';
+};
+/**
+ * @beta
+ */
+type InlineObjectPopover = {
+  snapshot: {
+    context: ActiveContext;
+    matches: (state: 'disabled' | 'enabled' | {
+      enabled: 'inactive' | 'active';
+    }) => boolean;
+  };
+  send: (event: InlineObjectPopoverEvent) => void;
+};
 /**
  * @beta
  * Manages the state and available events for an inline object popover.
  */
-export declare function useInlineObjectPopover(props: {
-  schemaTypes: ReadonlyArray<ToolbarInlineObjectSchemaType>
-}): InlineObjectPopover
-
+declare function useInlineObjectPopover(props: {
+  schemaTypes: ReadonlyArray<ToolbarInlineObjectSchemaType>;
+}): InlineObjectPopover;
+/**
+ * @beta
+ */
+type ListButtonEvent = {
+  type: 'toggle';
+};
+/**
+ * @beta
+ */
+type ListButton = {
+  snapshot: {
+    matches: (state: 'disabled' | 'enabled' | {
+      disabled: 'inactive';
+    } | {
+      disabled: 'active';
+    } | {
+      enabled: 'inactive';
+    } | {
+      enabled: 'active';
+    }) => boolean;
+  };
+  send: (event: ListButtonEvent) => void;
+};
 /**
  * @beta
  * Manages the state, keyboard shortcuts and available events for a list button.
  */
-export declare function useListButton(props: {
-  schemaType: ToolbarListSchemaType
-}): ListButton
-
+declare function useListButton(props: {
+  schemaType: ToolbarListSchemaType;
+}): ListButton;
 /**
  * @beta
- * Manages the state, keyboard shortcuts and available events for a style
- * selector.
  */
-export declare function useStyleSelector(props: {
-  schemaTypes: ReadonlyArray<ToolbarStyleSchemaType>
-}): StyleSelector
-
+type StyleSelectorEvent = {
+  type: 'toggle';
+  style: StyleSchemaType['name'];
+};
 /**
  * @beta
- *
- * Resolve the editor's full toolbar schema. Returns the union of every
- * decorator, annotation, list, style, block object and inline object declared
- * anywhere in the editor's schema graph that is reachable from a position
- * where text is edited - the root schema merged with the sub-schema of every
- * registered container whose field accepts text blocks. Useful for rendering
- * a static toolbar whose buttons stay stable across selection moves.
- *
- * Re-renders only when the schema graph or the extension callbacks change.
- * Pair with {@link useApplicableSchema} to determine which entries are
- * applicable at the current selection (which buttons should be enabled vs.
- * disabled).
  */
-export declare function useToolbarSchema(props: {
-  extendDecorator?: ExtendDecoratorSchemaType
-  extendAnnotation?: ExtendAnnotationSchemaType
-  extendList?: ExtendListSchemaType
-  extendBlockObject?: ExtendBlockObjectSchemaType
-  extendInlineObject?: ExtendInlineObjectSchemaType
-  extendStyle?: ExtendStyleSchemaType
-}): ToolbarSchema
-
-export {}
+type StyleSelector = {
+  snapshot: {
+    matches: (state: 'disabled' | 'enabled') => boolean;
+    context: {
+      activeStyle: StyleSchemaType['name'] | undefined;
+    };
+  };
+  send: (event: StyleSelectorEvent) => void;
+};
+/**
+ * @beta
+ * Manages the state, keyboard shortcuts and available events for a style
+ * selector.
+ */
+declare function useStyleSelector(props: {
+  schemaTypes: ReadonlyArray<ToolbarStyleSchemaType>;
+}): StyleSelector;
+export { AnnotationButton, AnnotationButtonEvent, AnnotationPopover, AnnotationPopoverEvent, type ApplicableSchema, BlockObjectButton, BlockObjectButtonEvent, BlockObjectPopover, BlockObjectPopoverEvent, DecoratorButton, DecoratorButtonEvent, ExtendAnnotationSchemaType, ExtendBlockObjectSchemaType, ExtendDecoratorSchemaType, ExtendInlineObjectSchemaType, ExtendListSchemaType, ExtendStyleSchemaType, HistoryButtons, HistoryButtonsEvent, InlineObjectButton, InlineObjectButtonEvent, InlineObjectPopover, InlineObjectPopoverEvent, ListButton, ListButtonEvent, StyleSelector, StyleSelectorEvent, ToolbarAnnotationSchemaType, ToolbarBlockObjectSchemaType, ToolbarDecoratorSchemaType, ToolbarInlineObjectSchemaType, ToolbarListSchemaType, ToolbarSchema, ToolbarStyleSchemaType, useAnnotationButton, useAnnotationPopover, useApplicableSchema, useBlockObjectButton, useBlockObjectPopover, useDecoratorButton, useHistoryButtons, useInlineObjectButton, useInlineObjectPopover, useListButton, useStyleSelector, useToolbarSchema };
+//# sourceMappingURL=index.d.ts.map