@import-ai/omnibox-editor 0.0.1

package/dist/components/tiptap-ui/slash-command-trigger-button/use-slash-command-trigger.d.ts

@@ -0,0 +1,96 @@
+import { type Editor } from "@tiptap/react";
+import type { Node } from "@tiptap/pm/model";
+export declare const SLASH_COMMAND_TRIGGER_SHORTCUT_KEY = "mod+/";
+/**
+ * Configuration for the slash command functionality
+ */
+export interface UseSlashCommandTriggerConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The node to apply trigger to
+     */
+    node?: Node | null;
+    /**
+     * The position of the node in the document
+     */
+    nodePos?: number | null;
+    /**
+     * The trigger text to insert
+     * @default "/"
+     */
+    trigger?: string;
+    /**
+     * Whether the button should hide when insertion is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful trigger insertion.
+     */
+    onTriggered?: (trigger: string) => void;
+}
+/**
+ * Checks if a slash command can be inserted in the current editor state
+ */
+export declare function canInsertSlashCommand(editor: Editor | null, node?: Node | null, nodePos?: number | null): boolean;
+/**
+ * Inserts a slash command at a specified node position or after the current selection
+ */
+export declare function insertSlashCommand(editor: Editor | null, trigger?: string, node?: Node | null, nodePos?: number | null): boolean;
+/**
+ * Determines if the slash command button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+    node?: Node | null;
+    nodePos?: number | null;
+}): boolean;
+/**
+ * Custom hook that provides slash command functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage - no params needed
+ * function MySimpleSlashButton() {
+ *   const { isVisible, handleSlashCommand } = useSlashCommandTrigger()
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleSlashCommand}>Insert Block</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedSlashButton() {
+ *   const { isVisible, handleSlashCommand, label } = useSlashCommandTrigger({
+ *     editor: myEditor,
+ *     trigger: "/",
+ *     hideWhenUnavailable: true,
+ *     onTriggered: (trigger) => console.log('Inserted:', trigger)
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleSlashCommand}
+ *       aria-label={label}
+ *     >
+ *       Insert Block
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useSlashCommandTrigger(config?: UseSlashCommandTriggerConfig): {
+    isVisible: boolean;
+    handleSlashCommand: () => boolean;
+    canInsert: boolean;
+    label: string;
+    shortcutKeys: string;
+    trigger: string;
+    Icon: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};

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

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

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

@@ -0,0 +1,8 @@
+import type { SuggestionMenuProps } from "@/components/tiptap-ui-utils/suggestion-menu";
+import type { SlashMenuConfig } from "@/components/tiptap-ui/slash-dropdown-menu/use-slash-dropdown-menu";
+import "@/components/tiptap-ui/slash-dropdown-menu/slash-dropdown-menu.css";
+type SlashDropdownMenuProps = Omit<SuggestionMenuProps, "items" | "children"> & {
+    config?: SlashMenuConfig;
+};
+export declare const SlashDropdownMenu: (props: SlashDropdownMenuProps) => import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,146 @@
+import type { Editor } from "@tiptap/react";
+import { type OmniboxEditorI18n } from "@/lib/i18n";
+import type { SuggestionItem } from "@/components/tiptap-ui-utils/suggestion-menu";
+export interface SlashMenuConfig {
+    aiEnabled?: boolean;
+    onAiAction?: (action: SlashMenuAiAction) => void;
+    enabledItems?: SlashMenuItemType[];
+    customItems?: SuggestionItem[];
+    itemGroups?: {
+        [key in SlashMenuItemType]?: string;
+    };
+    showGroups?: boolean;
+}
+declare function getSlashMenuTexts(i18n: OmniboxEditorI18n): {
+    ai_continue_writing: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    ai_ask: {
+        title: string;
+        subtext: string;
+        keywords: string[];
+        badge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+        group: string;
+    };
+    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 ReturnType<typeof getSlashMenuTexts>;
+export type SlashMenuAiAction = "ask" | "continue_writing";
+export declare function getSlashMenuItemAction(itemType: SlashMenuItemType): SlashMenuAiAction | null;
+export declare function getSlashMenuItemTypes(itemTypes: SlashMenuItemType[], config?: Pick<SlashMenuConfig, "aiEnabled">): ("emoji" | "image" | "table" | "mention" | "text" | "quote" | "toc" | "ai_continue_writing" | "ai_ask" | "heading_1" | "heading_2" | "heading_3" | "bullet_list" | "ordered_list" | "task_list" | "code_block" | "divider")[];
+/**
+ * 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,103 @@
+import type { ChainedCommands } from "@tiptap/react";
+import { type Editor } from "@tiptap/react";
+import { type OmniboxEditorI18n } from "@/lib/i18n";
+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 function getTextAlignLabel(align: TextAlign, i18n: OmniboxEditorI18n): 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,153 @@
+import type { Editor } from "@tiptap/react";
+import { type OmniboxEditorI18n } from "@/lib/i18n";
+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;
+})[];
+type BlockTypeOption = (typeof blockTypeOptions)[number];
+export declare function localizeBlockTypeOption(option: BlockTypeOption, i18n: OmniboxEditorI18n): BlockTypeOption;
+/**
+ * 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>;
+};
+export {};