@import-ai/omnibox-editor 0.0.1

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>;
+};

package/dist/components/tiptap-ui-primitive/avatar/avatar.d.ts

@@ -0,0 +1,23 @@
+import "@/components/tiptap-ui-primitive/avatar/avatar.css";
+type ImageLoadingStatus = "idle" | "loading" | "loaded" | "error";
+type Size = "default" | "sm" | "lg" | "xl";
+interface AvatarProps extends React.HTMLAttributes<HTMLSpanElement> {
+    size?: Size;
+    userColor?: string;
+}
+interface AvatarImageProps extends Omit<React.ImgHTMLAttributes<HTMLImageElement>, "onLoadingStatusChange" | "src"> {
+    src?: string;
+    onLoadingStatusChange?: (status: ImageLoadingStatus) => void;
+}
+interface AvatarFallbackProps extends React.HTMLAttributes<HTMLSpanElement> {
+    delayMs?: number;
+}
+interface AvatarGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    maxVisible?: number;
+    children: React.ReactNode;
+}
+export declare const Avatar: import("react").ForwardRefExoticComponent<AvatarProps & import("react").RefAttributes<HTMLSpanElement>>;
+export declare const AvatarImage: import("react").ForwardRefExoticComponent<AvatarImageProps & import("react").RefAttributes<HTMLImageElement>>;
+export declare const AvatarFallback: import("react").ForwardRefExoticComponent<AvatarFallbackProps & import("react").RefAttributes<HTMLSpanElement>>;
+export declare const AvatarGroup: React.FC<AvatarGroupProps>;
+export {};

package/dist/components/tiptap-ui-primitive/avatar/index.d.ts

@@ -0,0 +1 @@
+export * from "./avatar";

package/dist/components/tiptap-ui-primitive/badge/badge.d.ts

@@ -0,0 +1,11 @@
+import "@/components/tiptap-ui-primitive/badge/badge-colors.css";
+import "@/components/tiptap-ui-primitive/badge/badge-group.css";
+import "@/components/tiptap-ui-primitive/badge/badge.css";
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: "ghost" | "white" | "gray" | "green" | "yellow" | "default";
+    size?: "default" | "small";
+    appearance?: "default" | "subdued" | "emphasized";
+    trimText?: boolean;
+}
+export declare const Badge: import("react").ForwardRefExoticComponent<BadgeProps & import("react").RefAttributes<HTMLDivElement>>;
+export default Badge;

package/dist/components/tiptap-ui-primitive/badge/index.d.ts

@@ -0,0 +1 @@
+export * from "./badge";

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

@@ -0,0 +1,16 @@
+import "@/components/tiptap-ui-primitive/button/button-colors.css";
+import "@/components/tiptap-ui-primitive/button/button.css";
+export type ButtonVariant = "ghost" | "primary";
+export type ButtonSize = "small" | "default" | "large";
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    showTooltip?: boolean;
+    tooltip?: React.ReactNode;
+    shortcutKeys?: string;
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+}
+export declare const ShortcutDisplay: React.FC<{
+    shortcuts: string[];
+}>;
+export declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export default Button;

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

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

package/dist/components/tiptap-ui-primitive/button-group/button-group.d.ts

@@ -0,0 +1,10 @@
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+import { Separator } from "@/components/tiptap-ui-primitive/separator";
+declare const buttonGroupVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function ButtonGroup({ className, orientation, ...props }: React.ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants>): import("react").JSX.Element;
+declare function ButtonGroupText({ className, render, ...props }: useRender.ComponentProps<"div">): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare function ButtonGroupSeparator({ className, orientation, ...props }: React.ComponentProps<typeof Separator>): import("react").JSX.Element;
+export { ButtonGroup, ButtonGroupSeparator, ButtonGroupText, buttonGroupVariants, };

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

@@ -0,0 +1 @@
+export * from "./button-group";

package/dist/components/tiptap-ui-primitive/card/card.d.ts

@@ -0,0 +1,10 @@
+import "@/components/tiptap-ui-primitive/card/card.css";
+declare const Card: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const CardHeader: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const CardBody: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const CardItemGroup: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    orientation?: "horizontal" | "vertical";
+}, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const CardGroupLabel: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const CardFooter: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardBody, CardItemGroup, CardGroupLabel };

package/dist/components/tiptap-ui-primitive/card/index.d.ts

@@ -0,0 +1 @@
+export * from "./card";

package/dist/components/tiptap-ui-primitive/combobox/combobox.d.ts

@@ -0,0 +1,21 @@
+import * as Ariakit from "@ariakit/react";
+import "@/components/tiptap-ui-primitive/combobox/combobox.css";
+declare function ComboboxProvider({ ...props }: Ariakit.ComboboxProviderProps): import("react").JSX.Element;
+declare function ComboboxLabel({ className, ...props }: Ariakit.ComboboxLabelProps): import("react").JSX.Element;
+declare function Combobox({ className, ...props }: Ariakit.ComboboxProps): import("react").JSX.Element;
+declare function ComboboxInput({ className, children, disabled, showTrigger, showClear, ...props }: Ariakit.ComboboxProps & {
+    showTrigger?: boolean;
+    showClear?: boolean;
+}): import("react").JSX.Element;
+declare function ComboboxCancel({ className, ...props }: Ariakit.ComboboxCancelProps): import("react").JSX.Element;
+declare function ComboboxDisclosure({ className, ...props }: Ariakit.ComboboxDisclosureProps): import("react").JSX.Element;
+declare function ComboboxValue({ ...props }: Ariakit.ComboboxValueProps): import("react").JSX.Element;
+declare function ComboboxList({ className, ...props }: Ariakit.ComboboxListProps): import("react").JSX.Element;
+declare function ComboboxPopover({ className, ...props }: Ariakit.ComboboxPopoverProps): import("react").JSX.Element;
+declare function ComboboxGroup({ className, ...props }: Ariakit.ComboboxGroupProps): import("react").JSX.Element;
+declare function ComboboxGroupLabel({ className, ...props }: Ariakit.ComboboxGroupLabelProps): import("react").JSX.Element;
+declare function ComboboxRow({ className, ...props }: Ariakit.ComboboxRowProps): import("react").JSX.Element;
+declare function ComboboxItem({ className, ...props }: Ariakit.ComboboxItemProps): import("react").JSX.Element;
+declare function ComboboxItemCheck({ className, ...props }: Ariakit.ComboboxItemCheckProps): import("react").JSX.Element;
+declare function ComboboxItemValue({ className, ...props }: Ariakit.ComboboxItemValueProps): import("react").JSX.Element;
+export { ComboboxProvider, ComboboxLabel, Combobox, ComboboxInput, ComboboxCancel, ComboboxDisclosure, ComboboxValue, ComboboxList, ComboboxPopover, ComboboxGroup, ComboboxGroupLabel, ComboboxRow, ComboboxItem, ComboboxItemCheck, ComboboxItemValue, };

package/dist/components/tiptap-ui-primitive/combobox/index.d.ts

@@ -0,0 +1 @@
+export * from "./combobox";

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

@@ -0,0 +1,29 @@
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import "@/components/tiptap-ui-primitive/dropdown-menu/dropdown-menu.css";
+declare function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>): import("react").JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>): import("react").JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): import("react").JSX.Element;
+declare function DropdownMenuContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Content>): import("react").JSX.Element;
+declare function DropdownMenuGroup({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>): import("react").JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): import("react").JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem> & {
+    inset?: boolean;
+}): import("react").JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): import("react").JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem> & {
+    inset?: boolean;
+}): import("react").JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+    inset?: boolean;
+}): import("react").JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>): import("react").JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">): import("react").JSX.Element;
+declare function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>): import("react").JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+}): import("react").JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): import("react").JSX.Element;
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, };

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

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

package/dist/components/tiptap-ui-primitive/input/index.d.ts

@@ -0,0 +1 @@
+export * from "./input";

package/dist/components/tiptap-ui-primitive/input/input.d.ts

@@ -0,0 +1,3 @@
+import "@/components/tiptap-ui-primitive/input/input.css";
+declare function Input({ className, type, ...props }: React.ComponentProps<"input">): import("react").JSX.Element;
+export { Input };

package/dist/components/tiptap-ui-primitive/input-group/index.d.ts

@@ -0,0 +1 @@
+export * from "./input-group";

package/dist/components/tiptap-ui-primitive/input-group/input-group.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+import { Button } from "@/components/tiptap-ui-primitive/button";
+import "./input-group.css";
+declare function InputGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare const inputGroupAddonVariants: (props?: ({
+    align?: "inline-end" | "inline-start" | "block-end" | "block-start" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function InputGroupAddon({ className, align, ...props }: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>): React.JSX.Element;
+declare const inputGroupButtonVariants: (props?: ({
+    size?: "xs" | "sm" | "icon-xs" | "icon-sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function InputGroupButton({ className, type, variant, size, ...props }: Omit<React.ComponentProps<typeof Button>, "size" | "type"> & VariantProps<typeof inputGroupButtonVariants> & {
+    type?: "button" | "submit" | "reset";
+}): React.JSX.Element;
+declare function InputGroupText({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+declare function InputGroupInput({ className, ...props }: React.ComponentProps<"input">): React.JSX.Element;
+declare function InputGroupTextarea({ className, ...props }: React.ComponentProps<"textarea">): React.JSX.Element;
+export { InputGroup, InputGroupAddon, InputGroupButton, InputGroupText, InputGroupInput, InputGroupTextarea, };

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

@@ -0,0 +1,5 @@
+export * from "./menu";
+export * from "./menu-context";
+export * from "./menu-hooks";
+export * from "./menu-types";
+export * from "./menu-utils";

package/dist/components/tiptap-ui-primitive/menu/menu-context.d.ts

@@ -0,0 +1,5 @@
+import type { MenuContextValue } from "@/components/tiptap-ui-primitive/menu/menu-types";
+export declare const SearchableContext: import("react").Context<boolean>;
+export declare const MenuContext: import("react").Context<MenuContextValue>;
+export declare const useSearchableContext: () => boolean;
+export declare const useMenuContext: () => MenuContextValue;

package/dist/components/tiptap-ui-primitive/menu/menu-hooks.d.ts

@@ -0,0 +1,10 @@
+import * as Ariakit from "@ariakit/react";
+import type { ContextMenuAnchor, UseContextMenuReturn, UseMenuStoreReturn } from "@/components/tiptap-ui-primitive/menu/menu-types";
+export declare function useComboboxValueState(): readonly [
+    string,
+    (value: string) => void
+];
+export declare function useMenuPlacement(): string;
+export declare function useContextMenu(anchorRect: ContextMenuAnchor): UseContextMenuReturn;
+export declare function useFloatingMenuStore(): UseMenuStoreReturn;
+export declare function useMenuItemClick(menu?: Ariakit.MenuStore, preventClose?: boolean): (event: React.MouseEvent<HTMLElement, MouseEvent>) => false;

package/dist/components/tiptap-ui-primitive/menu/menu-types.d.ts

@@ -0,0 +1,44 @@
+import type * as React from "react";
+import type * as Ariakit from "@ariakit/react";
+export interface Action {
+    filterItems?: boolean;
+    group?: string;
+    icon?: React.ReactNode;
+    items?: Action[];
+    keywords?: string[];
+    label?: string;
+    value?: string;
+}
+export interface MenuItemProps extends Omit<Ariakit.ComboboxItemProps, "store"> {
+    group?: string;
+    name?: string;
+    parentGroup?: string;
+    preventClose?: boolean;
+}
+export interface MenuContextValue {
+    isRootMenu: boolean;
+    open: boolean;
+}
+export interface MenuProps extends Ariakit.MenuProviderProps {
+    trigger?: React.ReactNode;
+    value?: string;
+    onOpenChange?: Ariakit.MenuProviderProps["setOpen"];
+    onValueChange?: Ariakit.ComboboxProviderProps["setValue"];
+    onValuesChange?: Ariakit.MenuProviderProps["setValues"];
+}
+export interface MenuContentProps extends React.ComponentProps<typeof Ariakit.Menu> {
+    onClickOutside?: (event: MouseEvent | TouchEvent | FocusEvent) => void;
+}
+export interface ContextMenuAnchor {
+    x: number;
+    y: number;
+}
+export interface UseContextMenuReturn {
+    store: ReturnType<typeof Ariakit.useMenuStore>;
+    getAnchorRect: () => ContextMenuAnchor;
+    show: () => void;
+}
+export interface UseMenuStoreReturn {
+    store: ReturnType<typeof Ariakit.useMenuStore>;
+    show: (anchorElement: HTMLElement) => void;
+}

package/dist/components/tiptap-ui-primitive/menu/menu-utils.d.ts

@@ -0,0 +1,15 @@
+import type { Action } from "@/components/tiptap-ui-primitive/menu/menu-types";
+/**
+ * Filters menu items based on search value
+ * @param group - The action group containing items to filter
+ * @param searchValue - The search string to filter against
+ * @returns Filtered array of actions
+ */
+export declare function filterMenuItems({ items, ...group }: Action, searchValue: string): Action[];
+/**
+ * Filters menu groups based on search value
+ * @param menuGroups - Array of action groups to filter
+ * @param searchValue - The search string to filter against
+ * @returns Filtered array of action groups
+ */
+export declare function filterMenuGroups(menuGroups: Action[], searchValue: string): Action[];

package/dist/components/tiptap-ui-primitive/menu/menu.d.ts

@@ -0,0 +1,20 @@
+import * as Ariakit from "@ariakit/react";
+import type { MenuProps, MenuContentProps, MenuItemProps } from "@/components/tiptap-ui-primitive/menu";
+import "@/components/tiptap-ui-primitive/menu/menu.css";
+export declare function MenuProvider({ ...props }: Ariakit.MenuProviderProps): import("react").JSX.Element;
+export declare function Menu({ children, trigger, value, onOpenChange, onValueChange, onValuesChange, ...props }: MenuProps): import("react").JSX.Element;
+export declare function MenuContent({ children, className, ref, onClickOutside, ...props }: MenuContentProps): import("react").JSX.Element;
+export declare function MenuList({ className, ...props }: Ariakit.MenuListProps): import("react").JSX.Element;
+export declare function MenuButton({ className, ...props }: Ariakit.MenuButtonProps): import("react").JSX.Element;
+export declare function MenuButtonArrow({ className, ...props }: Ariakit.MenuButtonArrowProps): import("react").JSX.Element;
+export declare function MenuArrow({ className, ...props }: Ariakit.MenuArrowProps): import("react").JSX.Element;
+export declare function MenuHeading({ className, ...props }: Ariakit.MenuHeadingProps): import("react").JSX.Element;
+export declare function MenuDescription({ className, ...props }: Ariakit.MenuDescriptionProps): import("react").JSX.Element;
+export declare function MenuDismiss({ className, ...props }: Ariakit.MenuDismissProps): import("react").JSX.Element;
+export declare function MenuGroup({ className, ...props }: Ariakit.MenuGroupProps): import("react").JSX.Element;
+export declare function MenuGroupLabel({ className, ...props }: Ariakit.MenuGroupLabelProps): import("react").JSX.Element;
+export declare function MenuSeparator({ className, ...props }: Ariakit.MenuSeparatorProps): import("react").JSX.Element;
+export declare function MenuItemCheck({ className, ...props }: Ariakit.MenuItemCheckProps): import("react").JSX.Element;
+export declare function MenuItemCheckbox({ className, ...props }: Ariakit.MenuItemCheckboxProps): import("react").JSX.Element;
+export declare function MenuItemRadio({ className, ...props }: Ariakit.MenuItemRadioProps): import("react").JSX.Element;
+export declare function MenuItem({ name, value, preventClose, className, ...props }: MenuItemProps): import("react").JSX.Element;

package/dist/components/tiptap-ui-primitive/popover/index.d.ts

@@ -0,0 +1 @@
+export * from "./popover";

package/dist/components/tiptap-ui-primitive/popover/popover.d.ts

@@ -0,0 +1,6 @@
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+import "@/components/tiptap-ui-primitive/popover/popover.css";
+declare function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>): import("react").JSX.Element;
+declare function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>): import("react").JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>): import("react").JSX.Element;
+export { Popover, PopoverTrigger, PopoverContent };

package/dist/components/tiptap-ui-primitive/separator/index.d.ts

@@ -0,0 +1 @@
+export * from "./separator";

package/dist/components/tiptap-ui-primitive/separator/separator.d.ts

@@ -0,0 +1,5 @@
+export type Orientation = "horizontal" | "vertical";
+export declare function Separator({ decorative, orientation, className, ...props }: React.ComponentProps<"div"> & {
+    orientation?: Orientation;
+    decorative?: boolean;
+}): import("react").JSX.Element;

package/dist/components/tiptap-ui-primitive/spacer/index.d.ts

@@ -0,0 +1 @@
+export * from "./spacer";

package/dist/components/tiptap-ui-primitive/spacer/spacer.d.ts

@@ -0,0 +1,5 @@
+export type SpacerOrientation = "horizontal" | "vertical";
+export declare function Spacer({ orientation, size, style, ...props }: React.ComponentProps<"div"> & {
+    orientation?: SpacerOrientation;
+    size?: string | number;
+}): import("react").JSX.Element;

package/dist/components/tiptap-ui-primitive/textarea/index.d.ts

@@ -0,0 +1 @@
+export * from "./textarea";

package/dist/components/tiptap-ui-primitive/textarea/textarea.d.ts

@@ -0,0 +1,3 @@
+import "./textarea.css";
+declare function Textarea({ className, ...props }: React.ComponentProps<"textarea">): import("react").JSX.Element;
+export { Textarea };

package/dist/components/tiptap-ui-primitive/toolbar/index.d.ts

@@ -0,0 +1 @@
+export * from "./toolbar";

package/dist/components/tiptap-ui-primitive/toolbar/toolbar.d.ts

@@ -0,0 +1,9 @@
+import "@/components/tiptap-ui-primitive/toolbar/toolbar.css";
+type BaseProps = React.HTMLAttributes<HTMLDivElement>;
+interface ToolbarProps extends BaseProps {
+    variant?: "floating" | "fixed";
+}
+export declare const Toolbar: import("react").ForwardRefExoticComponent<ToolbarProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ToolbarGroup: import("react").ForwardRefExoticComponent<BaseProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ToolbarSeparator: import("react").ForwardRefExoticComponent<BaseProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/tiptap-ui-primitive/tooltip/index.d.ts

@@ -0,0 +1 @@
+export * from "./tooltip";

package/dist/components/tiptap-ui-primitive/tooltip/tooltip.d.ts

@@ -0,0 +1,29 @@
+import { FloatingPortal, type Placement } from "@floating-ui/react";
+import "@/components/tiptap-ui-primitive/tooltip/tooltip.css";
+interface TooltipProviderProps {
+    children: React.ReactNode;
+    initialOpen?: boolean;
+    placement?: Placement;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    delay?: number;
+    closeDelay?: number;
+    timeout?: number;
+    useDelayGroup?: boolean;
+}
+interface TooltipTriggerProps extends Omit<React.HTMLProps<HTMLElement>, "ref"> {
+    asChild?: boolean;
+    children: React.ReactNode;
+}
+interface TooltipContentProps extends Omit<React.HTMLProps<HTMLDivElement>, "ref"> {
+    children?: React.ReactNode;
+    portal?: boolean;
+    portalProps?: Omit<React.ComponentProps<typeof FloatingPortal>, "children">;
+}
+export declare function Tooltip({ children, ...props }: TooltipProviderProps): import("react").JSX.Element;
+export declare namespace Tooltip {
+    var displayName: string;
+}
+export declare const TooltipTrigger: import("react").ForwardRefExoticComponent<TooltipTriggerProps & import("react").RefAttributes<HTMLElement>>;
+export declare const TooltipContent: import("react").ForwardRefExoticComponent<TooltipContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/tiptap-ui-utils/floating-element/floating-element-utils.d.ts

@@ -0,0 +1,3 @@
+import type { Editor } from "@tiptap/react";
+export declare const isElementWithinEditor: (editor: Editor | null, element: Node | null) => boolean;
+export declare const isElementWithinExternalPortal: (element: Node | null) => boolean;

package/dist/components/tiptap-ui-utils/floating-element/floating-element.d.ts

@@ -0,0 +1,53 @@
+import type { HTMLAttributes } from "react";
+import { type Editor } from "@tiptap/react";
+import { type UseFloatingOptions } from "@floating-ui/react";
+export interface FloatingElementProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * The Tiptap editor instance to attach to.
+     */
+    editor?: Editor | null;
+    /**
+     * Controls whether the floating element should be visible.
+     * @default undefined
+     */
+    shouldShow?: boolean;
+    /**
+     * Additional options to pass to the floating UI.
+     */
+    floatingOptions?: Partial<UseFloatingOptions>;
+    /**
+     * Z-index for the floating element.
+     * @default 50
+     */
+    zIndex?: number;
+    /**
+     * Callback fired when the visibility state changes.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Reference element to position the floating element relative to.
+     * If provided, this takes precedence over getBoundingClientRect.
+     */
+    referenceElement?: HTMLElement | null;
+    /**
+     * Custom function to determine the position of the floating element.
+     * Only used if referenceElement is not provided.
+     * @default getSelectionBoundingRect
+     */
+    getBoundingClientRect?: (editor: Editor) => DOMRect | null;
+    /**
+     * Whether to close the floating element when Escape key is pressed.
+     * @default true
+     */
+    closeOnEscape?: boolean;
+    /**
+     * Whether to reset the text selection when the floating element is closed or clicked outside the editor.
+     * @default true
+     */
+    resetTextSelectionOnClose?: boolean;
+}
+/**
+ * A floating UI element that positions itself relative to the current selection in a Tiptap editor.
+ * Used for floating toolbars, menus, and other UI elements that need to appear near the text cursor.
+ */
+export declare const FloatingElement: import("react").ForwardRefExoticComponent<FloatingElementProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/tiptap-ui-utils/floating-element/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./floating-element";
+export * from "./floating-element-utils";

package/dist/components/tiptap-ui-utils/suggestion-menu/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./suggestion-menu";
+export * from "./suggestion-menu-types";
+export * from "./suggestion-menu-utils";