zs_library 0.6.21 → 0.7.0

package/dist/components/tiptap-editor/simple/components/tiptap-ui/list-button/use-list.d.ts

@@ -0,0 +1,97 @@
+import { Editor } from '@tiptap/react';
+export type ListType = "bulletList" | "orderedList" | "taskList";
+/**
+ * Configuration for the list functionality
+ */
+export interface UseListConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The type of list to toggle.
+     */
+    type: ListType;
+    /**
+     * Whether the button should hide when list is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful toggle.
+     */
+    onToggled?: () => void;
+}
+export declare const listIcons: {
+    bulletList: import('@remixicon/react').RemixiconComponentType;
+    orderedList: import('@remixicon/react').RemixiconComponentType;
+    taskList: import('@remixicon/react').RemixiconComponentType;
+};
+export declare const listLabels: Record<ListType, string>;
+export declare const LIST_SHORTCUT_KEYS: Record<ListType, string>;
+/**
+ * Checks if a list can be toggled in the current editor state
+ */
+export declare function canToggleList(editor: Editor | null, type: ListType, turnInto?: boolean): boolean;
+/**
+ * Checks if list is currently active
+ */
+export declare function isListActive(editor: Editor | null, type: ListType): boolean;
+/**
+ * Toggles list in the editor
+ */
+export declare function toggleList(editor: Editor | null, type: ListType): boolean;
+/**
+ * Determines if the list button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    type: ListType;
+    hideWhenUnavailable: boolean;
+}): boolean;
+/**
+ * Custom hook that provides list functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MySimpleListButton() {
+ *   const { isVisible, handleToggle, isActive } = useList({ type: "bulletList" })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleToggle}>Bullet List</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedListButton() {
+ *   const { isVisible, handleToggle, label, isActive } = useList({
+ *     type: "orderedList",
+ *     editor: myEditor,
+ *     hideWhenUnavailable: true,
+ *     onToggled: () => console.log('List toggled!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleToggle}
+ *       aria-label={label}
+ *       aria-pressed={isActive}
+ *     >
+ *       Toggle List
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useList(config: UseListConfig): {
+    isVisible: boolean;
+    isActive: boolean;
+    handleToggle: () => boolean;
+    canToggle: boolean;
+    label: string;
+    shortcutKeys: string;
+    Icon: import('@remixicon/react').RemixiconComponentType;
+};

package/dist/components/tiptap-editor/simple/components/tiptap-ui/list-dropdown-menu/index.d.ts

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

package/dist/components/tiptap-editor/simple/components/tiptap-ui/list-dropdown-menu/list-dropdown-menu.d.ts

@@ -0,0 +1,29 @@
+import { Editor } from '@tiptap/react';
+import { ListType } from '../list-button';
+import { ButtonProps } from '../../tiptap-ui-primitive/button';
+export interface ListDropdownMenuProps extends Omit<ButtonProps, "type"> {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor;
+    /**
+     * The list types to display in the dropdown.
+     */
+    types?: ListType[];
+    /**
+     * Whether the dropdown should be hidden when no list types are available
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback for when the dropdown opens or closes
+     */
+    onOpenChange?: (isOpen: boolean) => void;
+    /**
+     * Whether to render the dropdown menu in a portal
+     * @default false
+     */
+    portal?: boolean;
+}
+export declare function ListDropdownMenu({ editor: providedEditor, types, hideWhenUnavailable, onOpenChange, portal, ...props }: ListDropdownMenuProps): import("react/jsx-runtime").JSX.Element | null;
+export default ListDropdownMenu;

package/dist/components/tiptap-editor/simple/components/tiptap-ui/list-dropdown-menu/use-list-dropdown-menu.d.ts

@@ -0,0 +1,94 @@
+import { Editor } from '@tiptap/react';
+import { ListType } from '../list-button';
+/**
+ * Configuration for the list dropdown menu functionality
+ */
+export interface UseListDropdownMenuConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The list types to display in the dropdown.
+     * @default ["bulletList", "orderedList", "taskList"]
+     */
+    types?: ListType[];
+    /**
+     * Whether the dropdown should be hidden when no list types are available
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+}
+export interface ListOption {
+    label: string;
+    type: ListType;
+    icon: React.ElementType;
+}
+export declare const listOptions: ListOption[];
+export declare function canToggleAnyList(editor: Editor | null, listTypes: ListType[]): boolean;
+export declare function isAnyListActive(editor: Editor | null, listTypes: ListType[]): boolean;
+export declare function getFilteredListOptions(availableTypes: ListType[]): typeof listOptions;
+export declare function shouldShowListDropdown(params: {
+    editor: Editor | null;
+    listTypes: ListType[];
+    hideWhenUnavailable: boolean;
+    listInSchema: boolean;
+    canToggleAny: boolean;
+}): boolean;
+/**
+ * Gets the currently active list type from the available types
+ */
+export declare function getActiveListType(editor: Editor | null, availableTypes: ListType[]): ListType | undefined;
+/**
+ * Custom hook that provides list dropdown menu functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MyListDropdown() {
+ *   const {
+ *     isVisible,
+ *     activeType,
+ *     isAnyActive,
+ *     canToggleAny,
+ *     filteredLists,
+ *   } = useListDropdownMenu()
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <DropdownMenu>
+ *       // dropdown content
+ *     </DropdownMenu>
+ *   )
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedListDropdown() {
+ *   const {
+ *     isVisible,
+ *     activeType,
+ *   } = useListDropdownMenu({
+ *     editor: myEditor,
+ *     types: ["bulletList", "orderedList"],
+ *     hideWhenUnavailable: true,
+ *   })
+ *
+ *   // component implementation
+ * }
+ * ```
+ */
+export declare function useListDropdownMenu(config?: UseListDropdownMenuConfig): {
+    isVisible: boolean;
+    activeType: ListType | undefined;
+    isActive: boolean;
+    canToggle: boolean;
+    types: ListType[];
+    filteredLists: {
+        label: string;
+        type: ListType;
+        icon: React.ElementType;
+    }[];
+    label: string;
+    Icon: import('@remixicon/react').RemixiconComponentType;
+};

package/dist/components/tiptap-editor/simple/components/tiptap-ui/mark-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from './mark-button';
+export * from './use-mark';

package/dist/components/tiptap-editor/simple/components/tiptap-ui/mark-button/mark-button.d.ts

@@ -0,0 +1,23 @@
+import { Mark, UseMarkConfig } from './use-mark';
+import { ButtonProps } from '../../tiptap-ui-primitive/button';
+export interface MarkButtonProps extends Omit<ButtonProps, "type">, UseMarkConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+    /**
+     * Optional show shortcut keys in the button.
+     * @default false
+     */
+    showShortcut?: boolean;
+}
+export declare function MarkShortcutBadge({ type, shortcutKeys, }: {
+    type: Mark;
+    shortcutKeys?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Button component for toggling marks in a Tiptap editor.
+ *
+ * For custom button implementations, use the `useMark` hook instead.
+ */
+export declare const MarkButton: import('react').ForwardRefExoticComponent<MarkButtonProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-editor/simple/components/tiptap-ui/mark-button/use-mark.d.ts

@@ -0,0 +1,104 @@
+import { Editor } from '@tiptap/react';
+export type Mark = "bold" | "italic" | "strike" | "code" | "underline" | "superscript" | "subscript";
+/**
+ * Configuration for the mark functionality
+ */
+export interface UseMarkConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The type of mark to toggle
+     */
+    type: Mark;
+    /**
+     * Whether the button should hide when mark is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful mark toggle.
+     */
+    onToggled?: () => void;
+}
+export declare const markIcons: {
+    bold: import('@remixicon/react').RemixiconComponentType;
+    italic: import('@remixicon/react').RemixiconComponentType;
+    underline: import('@remixicon/react').RemixiconComponentType;
+    strike: import('@remixicon/react').RemixiconComponentType;
+    code: import('@remixicon/react').RemixiconComponentType;
+    superscript: import('@remixicon/react').RemixiconComponentType;
+    subscript: import('@remixicon/react').RemixiconComponentType;
+};
+export declare const MARK_SHORTCUT_KEYS: Record<Mark, string>;
+/**
+ * Checks if a mark can be toggled in the current editor state
+ */
+export declare function canToggleMark(editor: Editor | null, type: Mark): boolean;
+/**
+ * Checks if a mark is currently active
+ */
+export declare function isMarkActive(editor: Editor | null, type: Mark): boolean;
+/**
+ * Toggles a mark in the editor
+ */
+export declare function toggleMark(editor: Editor | null, type: Mark): boolean;
+/**
+ * Determines if the mark button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    type: Mark;
+    hideWhenUnavailable: boolean;
+}): boolean;
+/**
+ * Gets the formatted mark name
+ */
+export declare function getFormattedMarkName(type: Mark): string;
+/**
+ * Custom hook that provides mark functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MySimpleBoldButton() {
+ *   const { isVisible, handleMark } = useMark({ type: "bold" })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleMark}>Bold</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedItalicButton() {
+ *   const { isVisible, handleMark, label, isActive } = useMark({
+ *     editor: myEditor,
+ *     type: "italic",
+ *     hideWhenUnavailable: true,
+ *     onToggled: () => console.log('Mark toggled!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleMark}
+ *       aria-pressed={isActive}
+ *       aria-label={label}
+ *     >
+ *       Italic
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useMark(config: UseMarkConfig): {
+    isVisible: boolean;
+    isActive: boolean;
+    handleMark: () => boolean;
+    canToggle: boolean;
+    label: string;
+    shortcutKeys: string;
+    Icon: import('@remixicon/react').RemixiconComponentType;
+};

package/dist/components/tiptap-editor/simple/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-editor/simple/components/tiptap-ui/text-align-button/text-align-button.d.ts

@@ -0,0 +1,30 @@
+import { TextAlign, UseTextAlignConfig } from './use-text-align';
+import { ButtonProps } from '../../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-runtime").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-editor/simple/components/tiptap-ui/text-align-button/use-text-align.d.ts

@@ -0,0 +1,101 @@
+import { ChainedCommands, 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('@remixicon/react').RemixiconComponentType;
+    center: import('@remixicon/react').RemixiconComponentType;
+    right: import('@remixicon/react').RemixiconComponentType;
+    justify: import('@remixicon/react').RemixiconComponentType;
+};
+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('@remixicon/react').RemixiconComponentType;
+};

package/dist/components/tiptap-editor/simple/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-editor/simple/components/tiptap-ui/undo-redo-button/undo-redo-button.d.ts

@@ -0,0 +1,23 @@
+import { UndoRedoAction, UseUndoRedoConfig } from './use-undo-redo';
+import { ButtonProps } from '../../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-runtime").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-editor/simple/components/tiptap-ui/undo-redo-button/use-undo-redo.d.ts

@@ -0,0 +1,90 @@
+import { 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('@remixicon/react').RemixiconComponentType;
+    redo: import('@remixicon/react').RemixiconComponentType;
+};
+/**
+ * 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('@remixicon/react').RemixiconComponentType;
+};

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

@@ -0,0 +1,8 @@
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: "ghost" | "white" | "gray" | "green" | "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-editor/simple/components/tiptap-ui-primitive/badge/index.d.ts

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

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

@@ -0,0 +1,14 @@
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    className?: string;
+    showTooltip?: boolean;
+    tooltip?: React.ReactNode;
+    shortcutKeys?: string;
+}
+export declare const ShortcutDisplay: React.FC<{
+    shortcuts: string[];
+}>;
+export declare const Button: import('react').ForwardRefExoticComponent<ButtonProps & import('react').RefAttributes<HTMLButtonElement>>;
+export declare const ButtonGroup: import('react').ForwardRefExoticComponent<Omit<import('react').ClassAttributes<HTMLDivElement> & import('react').HTMLAttributes<HTMLDivElement> & {
+    orientation?: "horizontal" | "vertical";
+}, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+export default Button;

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

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

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

@@ -0,0 +1,9 @@
+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-editor/simple/components/tiptap-ui-primitive/card/index.d.ts

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

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

@@ -0,0 +1,16 @@
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare const DropdownMenuTrigger: import('react').ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuTriggerProps & import('react').RefAttributes<HTMLButtonElement>, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: import('react').ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & import('react').RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSub: import('react').FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: import('react').ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & import('react').RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: import('react').ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuItemProps & import('react').RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: import('react').ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & import('react').RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: import('react').ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & import('react').RefAttributes<HTMLDivElement>, "ref"> & {
+    portal?: boolean | React.ComponentProps<typeof DropdownMenuPortal>;
+} & import('react').RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: import('react').ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & import('react').RefAttributes<HTMLDivElement>, "ref"> & {
+    portal?: boolean;
+} & import('react').RefAttributes<HTMLDivElement>>;
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuGroup, DropdownMenuSub, DropdownMenuPortal, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };