cvnert-editor 0.1.0

package/dist/components/tiptap-ui/slash-dropdown-menu/use-slash-dropdown-menu.d.ts

@@ -0,0 +1,126 @@
+import type { Editor } from "@tiptap/react";
+import type { SuggestionItem } from "@/components/tiptap-ui-utils/suggestion-menu";
+export interface SlashMenuConfig {
+    enabledItems?: SlashMenuItemType[];
+    customItems?: SuggestionItem[];
+    itemGroups?: {
+        [key in SlashMenuItemType]?: string;
+    };
+    showGroups?: boolean;
+}
+declare const texts: {
+    text: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    heading_1: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    heading_2: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    heading_3: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    bullet_list: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    ordered_list: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    task_list: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    quote: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    code_block: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    mention: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    emoji: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    table: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    divider: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    toc: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    image: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+};
+export type SlashMenuItemType = keyof typeof texts;
+/**
+ * Custom hook for slash dropdown menu functionality
+ */
+export declare function useSlashDropdownMenu(config?: SlashMenuConfig): {
+    getSlashMenuItems: (editor: Editor) => SuggestionItem<any>[];
+    config: SlashMenuConfig | undefined;
+};
+export {};

package/dist/components/tiptap-ui/text-align-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./text-align-button";
+export * from "./use-text-align";

package/dist/components/tiptap-ui/text-align-button/text-align-button.d.ts

@@ -0,0 +1,30 @@
+import type { TextAlign, UseTextAlignConfig } from "@/components/tiptap-ui/text-align-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+type IconProps = React.SVGProps<SVGSVGElement>;
+type IconComponent = ({ className, ...props }: IconProps) => React.ReactElement;
+export interface TextAlignButtonProps extends Omit<ButtonProps, "type">, UseTextAlignConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+    /**
+     * Optional show shortcut keys in the button.
+     * @default false
+     */
+    showShortcut?: boolean;
+    /**
+     * Optional custom icon component to render instead of the default.
+     */
+    icon?: React.MemoExoticComponent<IconComponent> | React.FC<IconProps>;
+}
+export declare function TextAlignShortcutBadge({ align, shortcutKeys, }: {
+    align: TextAlign;
+    shortcutKeys?: string;
+}): import("react").JSX.Element;
+/**
+ * Button component for setting text alignment in a Tiptap editor.
+ *
+ * For custom button implementations, use the `useTextAlign` hook instead.
+ */
+export declare const TextAlignButton: import("react").ForwardRefExoticComponent<TextAlignButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/components/tiptap-ui/text-align-button/use-text-align.d.ts

@@ -0,0 +1,102 @@
+import type { ChainedCommands } from "@tiptap/react";
+import { type Editor } from "@tiptap/react";
+export type TextAlign = "left" | "center" | "right" | "justify";
+/**
+ * Configuration for the text align functionality
+ */
+export interface UseTextAlignConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The text alignment to apply.
+     */
+    align: TextAlign;
+    /**
+     * Whether the button should hide when alignment is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful alignment change.
+     */
+    onAligned?: () => void;
+}
+export declare const TEXT_ALIGN_SHORTCUT_KEYS: Record<TextAlign, string>;
+export declare const textAlignIcons: {
+    left: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    center: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    right: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    justify: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};
+export declare const textAlignLabels: Record<TextAlign, string>;
+/**
+ * Checks if text alignment can be performed in the current editor state
+ */
+export declare function canSetTextAlign(editor: Editor | null, align: TextAlign): boolean;
+export declare function hasSetTextAlign(commands: ChainedCommands): commands is ChainedCommands & {
+    setTextAlign: (align: TextAlign) => ChainedCommands;
+};
+/**
+ * Checks if the text alignment is currently active
+ */
+export declare function isTextAlignActive(editor: Editor | null, align: TextAlign): boolean;
+/**
+ * Sets text alignment in the editor
+ */
+export declare function setTextAlign(editor: Editor | null, align: TextAlign): boolean;
+/**
+ * Determines if the text align button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+    align: TextAlign;
+}): boolean;
+/**
+ * Custom hook that provides text align functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MySimpleAlignButton() {
+ *   const { isVisible, handleTextAlign } = useTextAlign({ align: "center" })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleTextAlign}>Align Center</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedAlignButton() {
+ *   const { isVisible, handleTextAlign, label, isActive } = useTextAlign({
+ *     editor: myEditor,
+ *     align: "right",
+ *     hideWhenUnavailable: true,
+ *     onAligned: () => console.log('Text aligned!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleTextAlign}
+ *       aria-pressed={isActive}
+ *       aria-label={label}
+ *     >
+ *       Align Right
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useTextAlign(config: UseTextAlignConfig): {
+    isVisible: boolean;
+    isActive: boolean;
+    handleTextAlign: () => boolean;
+    canAlign: boolean;
+    label: string;
+    shortcutKeys: string;
+    Icon: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element> | import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element> | import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element> | import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};

package/dist/components/tiptap-ui/text-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./text-button";
+export * from "./use-text";

package/dist/components/tiptap-ui/text-button/text-button.d.ts

@@ -0,0 +1,22 @@
+import type { UseTextConfig } from "@/components/tiptap-ui/text-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface TextButtonProps extends Omit<ButtonProps, "type">, UseTextConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+    /**
+     * Optional show shortcut keys in the button.
+     * @default false
+     */
+    showShortcut?: boolean;
+}
+export declare function TextShortcutBadge({ shortcutKeys, }: {
+    shortcutKeys?: string;
+}): import("react").JSX.Element;
+/**
+ * Button component for converting to text/paragraph in a Tiptap editor.
+ *
+ * For custom button implementations, use the `useText` hook instead.
+ */
+export declare const TextButton: import("react").ForwardRefExoticComponent<TextButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-ui/text-button/use-text.d.ts

@@ -0,0 +1,86 @@
+import { type Editor } from "@tiptap/react";
+export declare const TEXT_SHORTCUT_KEY = "mod+alt+0";
+/**
+ * Configuration for the text/paragraph functionality
+ */
+export interface UseTextConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * Whether the button should hide when text conversion is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful conversion.
+     */
+    onToggled?: () => void;
+}
+/**
+ * Returns whether we can toggle/turn the current selection into a paragraph.
+ * - When `turnInto === false`, it just checks the direct ability to set paragraph on the selection.
+ * - When `turnInto === true`, it additionally requires the selection to be within convertible types.
+ */
+export declare function canToggleText(editor: Editor | null, turnInto?: boolean): boolean;
+/**
+ * Checks if paragraph is currently active
+ */
+export declare function isParagraphActive(editor: Editor | null): boolean;
+/**
+ * Converts the current selection or node to paragraph
+ */
+export declare function toggleParagraph(editor: Editor | null): boolean;
+/**
+ * Determines if the text button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+}): boolean;
+/**
+ * Custom hook that provides text/paragraph functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage - no params needed
+ * function MySimpleTextButton() {
+ *   const { isVisible, handleToggle, isActive } = useText()
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleToggle}>Text</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedTextButton() {
+ *   const { isVisible, handleToggle, label, isActive } = useText({
+ *     editor: myEditor,
+ *     hideWhenUnavailable: true,
+ *     onToggled: () => console.log('Text converted!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleToggle}
+ *       aria-label={label}
+ *       aria-pressed={isActive}
+ *     >
+ *       Convert to Text
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useText(config?: UseTextConfig): {
+    isVisible: boolean;
+    isActive: boolean;
+    handleToggle: () => boolean;
+    canToggle: boolean;
+    label: string;
+    shortcutKeys: string;
+    Icon: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};

package/dist/components/tiptap-ui/turn-into-dropdown/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./turn-into-dropdown";
+export * from "./use-turn-into-dropdown";

package/dist/components/tiptap-ui/turn-into-dropdown/turn-into-dropdown.d.ts

@@ -0,0 +1,16 @@
+import type { Editor } from "@tiptap/react";
+import type { UseTurnIntoDropdownConfig } from "@/components/tiptap-ui/turn-into-dropdown";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface TurnIntoDropdownContentProps {
+    blockTypes?: string[];
+    editor?: Editor | null;
+}
+export declare function TurnIntoDropdownContent({ blockTypes, editor, }: TurnIntoDropdownContentProps): import("react").JSX.Element;
+export interface TurnIntoDropdownProps extends Omit<ButtonProps, "type">, UseTurnIntoDropdownConfig {
+    modal?: boolean;
+}
+/**
+ * Dropdown component for transforming block types in a Tiptap editor.
+ * For custom dropdown implementations, use the `useTurnIntoDropdown` hook instead.
+ */
+export declare const TurnIntoDropdown: import("react").ForwardRefExoticComponent<TurnIntoDropdownProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-ui/turn-into-dropdown/use-turn-into-dropdown.d.ts

@@ -0,0 +1,149 @@
+import type { Editor } from "@tiptap/react";
+import type { Level } from "@/components/tiptap-ui/heading-button";
+export declare const TURN_INTO_BLOCKS: string[];
+/**
+ * Configuration for the turn into dropdown functionality
+ */
+export interface UseTurnIntoDropdownConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * Whether the dropdown should hide when no options are available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Which block types to show in the dropdown
+     * @default ["paragraph", "heading", "bulletList", "orderedList", "taskList", "blockquote", "codeBlock"]
+     */
+    blockTypes?: string[];
+    /**
+     * Callback function called when the dropdown state changes.
+     */
+    onOpenChange?: (isOpen: boolean) => void;
+}
+export declare const blockTypeOptions: ({
+    type: string;
+    label: string;
+    isActive: (editor: Editor) => boolean;
+    level?: undefined;
+} | {
+    type: string;
+    label: string;
+    level: Level;
+    isActive: (editor: Editor) => boolean;
+})[];
+/**
+ * Checks if turn into functionality can be used in the current editor state
+ */
+export declare function canTurnInto(editor: Editor | null, allowedBlockTypes?: string[]): boolean;
+/**
+ * Gets filtered block type options based on available types
+ */
+export declare function getFilteredBlockTypeOptions(blockTypes?: string[]): ({
+    type: string;
+    label: string;
+    isActive: (editor: Editor) => boolean;
+    level?: undefined;
+} | {
+    type: string;
+    label: string;
+    level: Level;
+    isActive: (editor: Editor) => boolean;
+})[];
+/**
+ * Gets the currently active block type from the available options
+ */
+export declare function getActiveBlockType(editor: Editor | null, blockTypes?: string[]): {
+    type: string;
+    label: string;
+    isActive: (editor: Editor) => boolean;
+    level?: undefined;
+} | {
+    type: string;
+    label: string;
+    level: Level;
+    isActive: (editor: Editor) => boolean;
+};
+/**
+ * Determines if the turn into dropdown should be visible
+ */
+export declare function shouldShowTurnInto(params: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+    blockTypes?: string[];
+}): boolean;
+/**
+ * Custom hook that provides turn into dropdown functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MyTurnIntoDropdown() {
+ *   const {
+ *     isVisible,
+ *     canToggle,
+ *     activeBlockType,
+ *     handleOpenChange,
+ *     label,
+ *     Icon,
+ *   } = useTurnIntoDropdown()
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <DropdownMenu onOpenChange={handleOpenChange}>
+ *       // dropdown content
+ *     </DropdownMenu>
+ *   )
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedTurnIntoDropdown() {
+ *   const {
+ *     isVisible,
+ *     activeBlockType,
+ *   } = useTurnIntoDropdown({
+ *     editor: myEditor,
+ *     blockTypes: ["paragraph", "heading", "bulletList"],
+ *     hideWhenUnavailable: true,
+ *     onOpenChange: (isOpen) => console.log("Dropdown toggled", isOpen),
+ *   })
+ *
+ *   // component implementation
+ * }
+ * ```
+ */
+export declare function useTurnIntoDropdown(config?: UseTurnIntoDropdownConfig): {
+    isVisible: boolean;
+    canToggle: boolean;
+    isOpen: boolean;
+    setIsOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    activeBlockType: {
+        type: string;
+        label: string;
+        isActive: (editor: Editor) => boolean;
+        level?: undefined;
+    } | {
+        type: string;
+        label: string;
+        level: Level;
+        isActive: (editor: Editor) => boolean;
+    };
+    handleOpenChange: (open: boolean) => void;
+    filteredOptions: ({
+        type: string;
+        label: string;
+        isActive: (editor: Editor) => boolean;
+        level?: undefined;
+    } | {
+        type: string;
+        label: string;
+        level: Level;
+        isActive: (editor: Editor) => boolean;
+    })[];
+    label: string;
+    Icon: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};

package/dist/components/tiptap-ui/undo-redo-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./undo-redo-button";
+export * from "./use-undo-redo";

package/dist/components/tiptap-ui/undo-redo-button/undo-redo-button.d.ts

@@ -0,0 +1,23 @@
+import type { UndoRedoAction, UseUndoRedoConfig } from "@/components/tiptap-ui/undo-redo-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface UndoRedoButtonProps extends Omit<ButtonProps, "type">, UseUndoRedoConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+    /**
+     * Optional show shortcut keys in the button.
+     * @default false
+     */
+    showShortcut?: boolean;
+}
+export declare function HistoryShortcutBadge({ action, shortcutKeys, }: {
+    action: UndoRedoAction;
+    shortcutKeys?: string;
+}): import("react").JSX.Element;
+/**
+ * Button component for triggering undo/redo actions in a Tiptap editor.
+ *
+ * For custom button implementations, use the `useHistory` hook instead.
+ */
+export declare const UndoRedoButton: import("react").ForwardRefExoticComponent<UndoRedoButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-ui/undo-redo-button/use-undo-redo.d.ts

@@ -0,0 +1,90 @@
+import { type Editor } from "@tiptap/react";
+export type UndoRedoAction = "undo" | "redo";
+/**
+ * Configuration for the history functionality
+ */
+export interface UseUndoRedoConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The history action to perform (undo or redo).
+     */
+    action: UndoRedoAction;
+    /**
+     * Whether the button should hide when action is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful action execution.
+     */
+    onExecuted?: () => void;
+}
+export declare const UNDO_REDO_SHORTCUT_KEYS: Record<UndoRedoAction, string>;
+export declare const historyActionLabels: Record<UndoRedoAction, string>;
+export declare const historyIcons: {
+    undo: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    redo: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};
+/**
+ * Checks if a history action can be executed
+ */
+export declare function canExecuteUndoRedoAction(editor: Editor | null, action: UndoRedoAction): boolean;
+/**
+ * Executes a history action on the editor
+ */
+export declare function executeUndoRedoAction(editor: Editor | null, action: UndoRedoAction): boolean;
+/**
+ * Determines if the history button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+    action: UndoRedoAction;
+}): boolean;
+/**
+ * Custom hook that provides history functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MySimpleUndoButton() {
+ *   const { isVisible, handleAction } = useHistory({ action: "undo" })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleAction}>Undo</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedRedoButton() {
+ *   const { isVisible, handleAction, label } = useHistory({
+ *     editor: myEditor,
+ *     action: "redo",
+ *     hideWhenUnavailable: true,
+ *     onExecuted: () => console.log('Action executed!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleAction}
+ *       aria-label={label}
+ *     >
+ *       Redo
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useUndoRedo(config: UseUndoRedoConfig): {
+    isVisible: boolean;
+    handleAction: () => boolean;
+    canExecute: boolean;
+    label: string;
+    shortcutKeys: string;
+    Icon: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element> | import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};