canny-ui-react 2.0.0 → 4.0.0

package/dist/components/Layout/AspectRatio.d.ts

@@ -0,0 +1,11 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export interface AspectRatioProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Ratio = width / height. e.g. 16/9, 4/3, 1, 21/9. Default 16/9. */
+    ratio?: number;
+    children?: ReactNode;
+}
+/**
+ * Locks a child to a fixed aspect ratio. Useful for video/image tiles,
+ * map embeds, and avatar grids. Pure CSS via `aspect-ratio`.
+ */
+export declare const AspectRatio: import("react").ForwardRefExoticComponent<AspectRatioProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/Layout/Center.d.ts

@@ -0,0 +1,7 @@
+import type { ElementType, ForwardedRef, ReactElement } from 'react';
+import type { BoxProps } from './Box';
+export type CenterProps<E extends ElementType = 'div'> = Omit<BoxProps<E>, 'display' | 'align' | 'justify'>;
+/** Flex-centers its children (both axes). */
+export declare const Center: <E extends ElementType = "div">(props: CenterProps<E> & {
+    ref?: ForwardedRef<Element>;
+}) => ReactElement;

package/dist/components/Layout/Grid.d.ts

@@ -2,9 +2,15 @@ import type { ElementType, ForwardedRef, ReactElement } from 'react';
 import type { BoxProps } from './Box';
 type GridCols = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
 export type GridProps<E extends ElementType = 'div'> = Omit<BoxProps<E>, 'display' | 'direction'> & {
+    /** Fixed column count. Maps to `.grid-cols-{n}` utility. Ignored if `minColWidth` is set. */
     cols?: GridCols;
+    /**
+     * Auto-fit responsive grid: `repeat(auto-fit, minmax(minColWidth, 1fr))`.
+     * Pass a CSS length (e.g. `'240px'`, `'18rem'`).
+     */
+    minColWidth?: string;
 };
-/** CSS Grid container. `cols` maps to `.grid-cols-{n}` utility. */
+/** CSS Grid container. Use `cols` for fixed tracks, or `minColWidth` for responsive auto-fit. */
 export declare const Grid: <E extends ElementType = "div">(props: GridProps<E> & {
     ref?: ForwardedRef<Element>;
 }) => ReactElement;

package/dist/components/Layout/Group.d.ts

@@ -0,0 +1,10 @@
+import type { ElementType, ForwardedRef, ReactElement } from 'react';
+import type { BoxProps } from './Box';
+export type GroupProps<E extends ElementType = 'div'> = Omit<BoxProps<E>, 'direction' | 'display'>;
+/**
+ * Horizontal flex row tuned for toolbars / trigger groups.
+ * Defaults: align center, gap 2, wrap on overflow.
+ */
+export declare const Group: <E extends ElementType = "div">(props: GroupProps<E> & {
+    ref?: ForwardedRef<Element>;
+}) => ReactElement;

package/dist/components/Layout/index.d.ts

@@ -4,10 +4,16 @@ export { Grid } from './Grid';
 export { Container } from './Container';
 export { Divider } from './Divider';
 export { Spacer } from './Spacer';
+export { AspectRatio } from './AspectRatio';
+export { Center } from './Center';
+export { Group } from './Group';
 export type { BoxProps } from './Box';
 export type { StackProps, RowProps } from './Stack';
 export type { GridProps } from './Grid';
 export type { ContainerProps, ContainerSize } from './Container';
 export type { DividerProps } from './Divider';
 export type { SpacerProps } from './Spacer';
+export type { AspectRatioProps } from './AspectRatio';
+export type { CenterProps } from './Center';
+export type { GroupProps } from './Group';
 export type { Space, Align, Justify, Direction, Display, LayoutProps } from './layout.types';

package/dist/components/List/List.d.ts

@@ -0,0 +1,42 @@
+import type { ElementType, HTMLAttributes, ReactNode, MouseEventHandler } from 'react';
+export type ListVariant = 'plain' | 'bordered' | 'dividers';
+export type ListSize = 'sm' | 'md' | 'lg';
+export interface ListProps extends HTMLAttributes<HTMLUListElement> {
+    /** Visual style. Default: `dividers`. */
+    variant?: ListVariant;
+    /** Row size. Default: `md`. */
+    size?: ListSize;
+    /** Use this when items have explicit dividers via `<ListSeparator>` to
+     * disable automatic divider rendering. */
+    dense?: boolean;
+}
+export declare const List: import("react").ForwardRefExoticComponent<ListProps & import("react").RefAttributes<HTMLUListElement>>;
+export interface ListItemProps {
+    /** Leading icon or avatar. */
+    leading?: ReactNode;
+    /** Trailing actions (button, chip, badge). */
+    trailing?: ReactNode;
+    /** Primary text — bold/regular depending on variant. */
+    primary?: ReactNode;
+    /** Secondary text — muted, single-line by default. */
+    secondary?: ReactNode;
+    /** Whole-row click handler. Becomes role=button. */
+    onClick?: MouseEventHandler<HTMLLIElement>;
+    /** Render the row as a link by passing an `href`. */
+    href?: string;
+    /** Disable interactivity + visual. */
+    disabled?: boolean;
+    /** Render as currently-active row. */
+    active?: boolean;
+    /** Override the rendered element (default: `li`, `a` if href, `button` if onClick). */
+    as?: ElementType;
+    /** Accessible name override (when `primary` isn't a string). */
+    'aria-label'?: string;
+    /** Free-form children — overrides the leading/primary/secondary/trailing slots. */
+    children?: ReactNode;
+    /** Extra className. */
+    className?: string;
+}
+export declare const ListItem: import("react").ForwardRefExoticComponent<ListItemProps & import("react").RefAttributes<HTMLElement>>;
+export declare const ListSeparator: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLLIElement> & import("react").RefAttributes<HTMLLIElement>>;
+export declare const ListSubheader: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLLIElement> & import("react").RefAttributes<HTMLLIElement>>;

package/dist/components/List/index.d.ts

@@ -0,0 +1,2 @@
+export { List, ListItem, ListSeparator, ListSubheader } from './List';
+export type { ListProps, ListItemProps, ListVariant, ListSize } from './List';

package/dist/components/Menu/Menu.d.ts

@@ -0,0 +1,51 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+import * as RadixMenu from '@radix-ui/react-dropdown-menu';
+export declare const Menu: import("react").FC<RadixMenu.DropdownMenuProps>;
+export declare const MenuTrigger: import("react").ForwardRefExoticComponent<RadixMenu.DropdownMenuTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface MenuContentProps extends ComponentPropsWithoutRef<typeof RadixMenu.Content> {
+    className?: string;
+    /** Visual size — controls padding + font size. Default: `md`. */
+    size?: 'sm' | 'md';
+}
+/**
+ * The popup panel. Wrap in `<Menu>` and pair with `<MenuTrigger>`.
+ *
+ * @example
+ *   <Menu>
+ *     <MenuTrigger asChild><Button>Actions</Button></MenuTrigger>
+ *     <MenuContent>
+ *       <MenuItem onSelect={...}>Edit</MenuItem>
+ *       <MenuSeparator />
+ *       <MenuItem destructive onSelect={...}>Delete</MenuItem>
+ *     </MenuContent>
+ *   </Menu>
+ */
+export declare const MenuContent: import("react").ForwardRefExoticComponent<MenuContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface MenuItemProps extends ComponentPropsWithoutRef<typeof RadixMenu.Item> {
+    /** Leading icon. */
+    icon?: ReactNode;
+    /** Right-aligned shortcut hint (e.g. `⌘C`). */
+    shortcut?: ReactNode;
+    /** Apply danger styling (red text, danger hover). */
+    destructive?: boolean;
+}
+export declare const MenuItem: import("react").ForwardRefExoticComponent<MenuItemProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface MenuCheckboxItemProps extends ComponentPropsWithoutRef<typeof RadixMenu.CheckboxItem> {
+    shortcut?: ReactNode;
+}
+export declare const MenuCheckboxItem: import("react").ForwardRefExoticComponent<MenuCheckboxItemProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const MenuRadioGroup: import("react").ForwardRefExoticComponent<RadixMenu.DropdownMenuRadioGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface MenuRadioItemProps extends ComponentPropsWithoutRef<typeof RadixMenu.RadioItem> {
+    shortcut?: ReactNode;
+}
+export declare const MenuRadioItem: import("react").ForwardRefExoticComponent<MenuRadioItemProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface MenuLabelProps extends ComponentPropsWithoutRef<typeof RadixMenu.Label> {
+}
+export declare const MenuLabel: import("react").ForwardRefExoticComponent<MenuLabelProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const MenuSeparator: import("react").ForwardRefExoticComponent<Omit<RadixMenu.DropdownMenuSeparatorProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const MenuSub: import("react").FC<RadixMenu.DropdownMenuSubProps>;
+export interface MenuSubTriggerProps extends ComponentPropsWithoutRef<typeof RadixMenu.SubTrigger> {
+    icon?: ReactNode;
+}
+export declare const MenuSubTrigger: import("react").ForwardRefExoticComponent<MenuSubTriggerProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const MenuSubContent: import("react").ForwardRefExoticComponent<Omit<RadixMenu.DropdownMenuSubContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/Menu/index.d.ts

@@ -0,0 +1,2 @@
+export { Menu, MenuTrigger, MenuContent, MenuItem, MenuCheckboxItem, MenuRadioGroup, MenuRadioItem, MenuLabel, MenuSeparator, MenuSub, MenuSubTrigger, MenuSubContent, } from './Menu';
+export type { MenuContentProps, MenuItemProps, MenuCheckboxItemProps, MenuRadioItemProps, MenuLabelProps, MenuSubTriggerProps, } from './Menu';

package/dist/components/Pagination/Pagination.d.ts

@@ -0,0 +1,22 @@
+export interface PaginationProps {
+    /** Current page (1-based). */
+    page: number;
+    /** Total number of pages. */
+    pageCount: number;
+    /** Fired with the new page when the user clicks. */
+    onPageChange: (page: number) => void;
+    /** Pages to show on each side of the current page. Default 1. */
+    siblingCount?: number;
+    /** Whether to always show the first/last page. Default true. */
+    showEdges?: boolean;
+    /** Hide the prev/next chevrons. */
+    hideControls?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+    'aria-label'?: string;
+}
+/**
+ * Pagination — page-number nav with prev/next chevrons. Server-driven:
+ * pass `page`, `pageCount`, and `onPageChange`.
+ */
+export declare const Pagination: import("react").ForwardRefExoticComponent<PaginationProps & import("react").RefAttributes<HTMLElement>>;

package/dist/components/Pagination/index.d.ts

@@ -0,0 +1,2 @@
+export { Pagination } from './Pagination';
+export type { PaginationProps } from './Pagination';

package/dist/components/PanelGroup/PanelGroup.d.ts

@@ -0,0 +1,33 @@
+import type { HTMLAttributes, PointerEvent } from 'react';
+export type PanelDirection = 'horizontal' | 'vertical';
+export interface PanelProps extends HTMLAttributes<HTMLDivElement> {
+    /** Initial size as a percentage of the group. */
+    defaultSize?: number;
+    /** Minimum size in percent. Default 10. */
+    minSize?: number;
+    /** Maximum size in percent. Default 90. */
+    maxSize?: number;
+}
+export declare const Panel: import("react").ForwardRefExoticComponent<PanelProps & import("react").RefAttributes<HTMLDivElement>>;
+interface HandleInternal {
+    direction: PanelDirection;
+    valueNow: number;
+    valueMin: number;
+    valueMax: number;
+    onResizeStart: (e: PointerEvent<HTMLDivElement>) => void;
+    onKeyResize: (dir: 1 | -1) => void;
+}
+export interface PanelResizeHandleProps extends HTMLAttributes<HTMLDivElement> {
+    disabled?: boolean;
+    /** @internal injected by PanelGroup */
+    __internal?: HandleInternal;
+}
+export declare const PanelResizeHandle: import("react").ForwardRefExoticComponent<PanelResizeHandleProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface PanelGroupProps extends HTMLAttributes<HTMLDivElement> {
+    /** Layout axis. Default `'horizontal'`. */
+    direction?: PanelDirection;
+}
+export declare const PanelGroup: import("react").ForwardRefExoticComponent<PanelGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+/** No-op kept for drop-in compatibility with `react-resizable-panels`. */
+export declare function disableGlobalCursorStyles(): void;
+export {};

package/dist/components/PanelGroup/index.d.ts

@@ -0,0 +1,2 @@
+export { PanelGroup, Panel, PanelResizeHandle, disableGlobalCursorStyles } from './PanelGroup';
+export type { PanelGroupProps, PanelProps, PanelResizeHandleProps, PanelDirection, } from './PanelGroup';

package/dist/components/Popover/Popover.d.ts

@@ -0,0 +1,24 @@
+import type { ComponentPropsWithoutRef } from 'react';
+import * as RadixPopover from '@radix-ui/react-popover';
+/**
+ * Popover root. Controlled (`open` + `onOpenChange`) or uncontrolled.
+ * Wrap a `<PopoverTrigger>` and `<PopoverContent>`.
+ *
+ * @example
+ *   <Popover>
+ *     <PopoverTrigger asChild><Button>Filters</Button></PopoverTrigger>
+ *     <PopoverContent side="bottom" align="end">
+ *       <FilterForm />
+ *     </PopoverContent>
+ *   </Popover>
+ */
+export declare const Popover: import("react").FC<RadixPopover.PopoverProps>;
+export declare const PopoverTrigger: import("react").ForwardRefExoticComponent<RadixPopover.PopoverTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const PopoverAnchor: import("react").ForwardRefExoticComponent<RadixPopover.PopoverAnchorProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const PopoverClose: import("react").ForwardRefExoticComponent<RadixPopover.PopoverCloseProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface PopoverContentProps extends ComponentPropsWithoutRef<typeof RadixPopover.Content> {
+    className?: string;
+    /** Render the small directional arrow on the popover. Default: false. */
+    withArrow?: boolean;
+}
+export declare const PopoverContent: import("react").ForwardRefExoticComponent<PopoverContentProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/Popover/index.d.ts

@@ -0,0 +1,2 @@
+export { Popover, PopoverTrigger, PopoverAnchor, PopoverClose, PopoverContent, } from './Popover';
+export type { PopoverContentProps } from './Popover';

package/dist/components/Slider/Slider.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+import * as SliderPrimitive from '@radix-ui/react-slider';
+export interface SliderProps extends ComponentPropsWithoutRef<typeof SliderPrimitive.Root> {
+    size?: 'sm' | 'md' | 'lg';
+    color?: 'primary' | 'success' | 'warning' | 'danger';
+    /** Show inline value bubble above the active thumb on hover/focus. */
+    showValue?: boolean;
+    /** Format value for the bubble. Default: `String(v)`. */
+    formatValue?: (v: number) => ReactNode;
+}
+/**
+ * Slider — single or range value picker. Pass an array length 1 for single,
+ * length 2 for range. Built on @radix-ui/react-slider.
+ */
+export declare const Slider: import("react").ForwardRefExoticComponent<SliderProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/components/Slider/index.d.ts

@@ -0,0 +1,2 @@
+export { Slider } from './Slider';
+export type { SliderProps } from './Slider';

package/dist/components/Stepper/Stepper.d.ts

@@ -0,0 +1,16 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export interface StepperStep {
+    label: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+}
+export interface StepperProps extends Omit<HTMLAttributes<HTMLOListElement>, 'children'> {
+    steps: StepperStep[];
+    /** Active step index (0-based). Steps before this are marked complete. */
+    active: number;
+    orientation?: 'horizontal' | 'vertical';
+    size?: 'sm' | 'md';
+    /** Fired when a previously-completed step is clicked. */
+    onStepClick?: (index: number) => void;
+}
+export declare const Stepper: import("react").ForwardRefExoticComponent<StepperProps & import("react").RefAttributes<HTMLOListElement>>;

package/dist/components/Stepper/index.d.ts

@@ -0,0 +1,2 @@
+export { Stepper } from './Stepper';
+export type { StepperProps, StepperStep } from './Stepper';

package/dist/components/Tabs/Tabs.d.ts

@@ -0,0 +1,34 @@
+import type { ComponentPropsWithoutRef } from 'react';
+import * as RadixTabs from '@radix-ui/react-tabs';
+export type TabsVariant = 'line' | 'pills' | 'segmented';
+export type TabsSize = 'sm' | 'md' | 'lg';
+/**
+ * Tabbed view container. Built on @radix-ui/react-tabs — handles roving
+ * tabindex, arrow-key nav, and proper ARIA wiring out of the box.
+ *
+ * @example
+ *   <Tabs defaultValue="overview">
+ *     <TabsList>
+ *       <TabsTrigger value="overview">Overview</TabsTrigger>
+ *       <TabsTrigger value="activity">Activity</TabsTrigger>
+ *     </TabsList>
+ *     <TabsContent value="overview">…</TabsContent>
+ *     <TabsContent value="activity">…</TabsContent>
+ *   </Tabs>
+ */
+export interface TabsProps extends ComponentPropsWithoutRef<typeof RadixTabs.Root> {
+    /** Visual style. Default: `line`. */
+    variant?: TabsVariant;
+    /** Size preset. Default: `md`. */
+    size?: TabsSize;
+}
+export declare const Tabs: import("react").ForwardRefExoticComponent<TabsProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const TabsList: import("react").ForwardRefExoticComponent<Omit<RadixTabs.TabsListProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export interface TabsTriggerProps extends ComponentPropsWithoutRef<typeof RadixTabs.Trigger> {
+    /** Optional leading icon. */
+    icon?: React.ReactNode;
+    /** Optional right-aligned badge (count, status). */
+    badge?: React.ReactNode;
+}
+export declare const TabsTrigger: import("react").ForwardRefExoticComponent<TabsTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const TabsContent: import("react").ForwardRefExoticComponent<Omit<RadixTabs.TabsContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/Tabs/index.d.ts

@@ -0,0 +1,2 @@
+export { Tabs, TabsList, TabsTrigger, TabsContent } from './Tabs';
+export type { TabsProps, TabsTriggerProps, TabsVariant, TabsSize } from './Tabs';

package/dist/components/Timeline/Timeline.d.ts

@@ -0,0 +1,55 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export type TimelineDotColor = 'primary' | 'success' | 'warning' | 'danger' | 'info' | 'neutral';
+/** Which side the content sits on relative to the central rail. */
+export type TimelinePosition = 'right' | 'left' | 'alternate';
+/** Rail direction. */
+export type TimelineOrientation = 'vertical' | 'horizontal';
+/** Density preset — scales dots, connector thickness, and type. */
+export type TimelineSize = 'sm' | 'md' | 'lg';
+export interface TimelineProps extends HTMLAttributes<HTMLOListElement> {
+    /** Side the content sits on relative to the rail. Default `'right'`. (Vertical only.) */
+    position?: TimelinePosition;
+    /** Rail direction. Default `'vertical'`. */
+    orientation?: TimelineOrientation;
+    /** Density preset. Default `'md'`. */
+    size?: TimelineSize;
+}
+export declare const Timeline: import("react").ForwardRefExoticComponent<TimelineProps & import("react").RefAttributes<HTMLOListElement>>;
+export type TimelineItemProps = HTMLAttributes<HTMLLIElement>;
+export declare const TimelineItem: import("react").ForwardRefExoticComponent<TimelineItemProps & import("react").RefAttributes<HTMLLIElement>>;
+export type TimelineSeparatorProps = HTMLAttributes<HTMLDivElement>;
+export declare const TimelineSeparator: import("react").ForwardRefExoticComponent<TimelineSeparatorProps & import("react").RefAttributes<HTMLDivElement>>;
+/** Dot fill treatment. */
+export type TimelineDotVariant = 'filled' | 'outlined' | 'soft';
+export interface TimelineDotProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Semantic color. Default `'neutral'`. */
+    color?: TimelineDotColor;
+    /** Fill treatment: filled (default), outlined ring, or soft tint. */
+    variant?: TimelineDotVariant;
+    /** Optional icon (or number) rendered inside the dot. */
+    icon?: ReactNode;
+    /** Pulsing ring to mark the current step. Respects reduced-motion. */
+    active?: boolean;
+}
+export declare const TimelineDot: import("react").ForwardRefExoticComponent<TimelineDotProps & import("react").RefAttributes<HTMLSpanElement>>;
+/** Connector line style. */
+export type TimelineConnectorLineStyle = 'solid' | 'dashed' | 'dotted';
+export interface TimelineConnectorProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Tint the segment to show a completed step. Omit for a neutral hairline. */
+    color?: TimelineDotColor;
+    /** Line style. Default `'solid'`. */
+    lineStyle?: TimelineConnectorLineStyle;
+}
+export declare const TimelineConnector: import("react").ForwardRefExoticComponent<TimelineConnectorProps & import("react").RefAttributes<HTMLSpanElement>>;
+/** Content treatment: plain, bordered card, or elevated card. */
+export type TimelineContentVariant = 'plain' | 'card' | 'elevated';
+export interface TimelineContentProps extends HTMLAttributes<HTMLDivElement> {
+    /** `'card'` = bordered block, `'elevated'` = card with shadow. Default `'plain'`. */
+    variant?: TimelineContentVariant;
+    /** Adds a colored left-accent border to a card, matched to a status color. */
+    accentColor?: TimelineDotColor;
+}
+export declare const TimelineContent: import("react").ForwardRefExoticComponent<TimelineContentProps & import("react").RefAttributes<HTMLDivElement>>;
+/** Slot rendered on the opposite side of the rail from the content (e.g. a timestamp). */
+export type TimelineOppositeContentProps = HTMLAttributes<HTMLDivElement>;
+export declare const TimelineOppositeContent: import("react").ForwardRefExoticComponent<TimelineOppositeContentProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/Timeline/index.d.ts

@@ -0,0 +1,2 @@
+export { Timeline, TimelineItem, TimelineSeparator, TimelineDot, TimelineConnector, TimelineContent, TimelineOppositeContent, } from './Timeline';
+export type { TimelineDotColor, TimelinePosition, TimelineOrientation, TimelineSize, TimelineDotVariant, TimelineConnectorLineStyle, TimelineContentVariant, TimelineDotProps, TimelineProps, TimelineItemProps, TimelineSeparatorProps, TimelineConnectorProps, TimelineContentProps, TimelineOppositeContentProps, } from './Timeline';

package/dist/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,46 @@
+import type { ReactNode } from 'react';
+import * as RadixTooltip from '@radix-ui/react-tooltip';
+/**
+ * Tooltip provider — wrap your app once. Controls the global delay so the
+ * first tooltip in a group has a longer delay, then subsequent tooltips
+ * appear instantly.
+ *
+ * @example
+ *   <TooltipProvider delayDuration={500}>
+ *     <App />
+ *   </TooltipProvider>
+ */
+export declare const TooltipProvider: import("react").FC<RadixTooltip.TooltipProviderProps>;
+export interface TooltipProps {
+    /** The element that triggers the tooltip on hover/focus. */
+    children: ReactNode;
+    /** Tooltip text or node. */
+    content: ReactNode;
+    /** Side preference. Auto-flips when there's no room. Default: `top`. */
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    /** Alignment along the side. Default: `center`. */
+    align?: 'start' | 'center' | 'end';
+    /** Pixels between the trigger and the tooltip. Default: 6. */
+    sideOffset?: number;
+    /** Override delay (ms) before showing. Falls back to TooltipProvider's delay. */
+    delayDuration?: number;
+    /** Controlled open state. Mostly for testing. */
+    open?: boolean;
+    /** Disable the tooltip but keep the trigger interactive. */
+    disabled?: boolean;
+    /** Extra className on the popup. */
+    contentClassName?: string;
+}
+/**
+ * Single-shot tooltip. Pass any element as `children` and it becomes the
+ * trigger. The element must accept a ref (or wrap in `asChild` via Radix).
+ *
+ * @example
+ *   <Tooltip content="Copy to clipboard">
+ *     <IconButton><Copy size={14} /></IconButton>
+ *   </Tooltip>
+ */
+export declare const Tooltip: import("react").ForwardRefExoticComponent<TooltipProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const TooltipRoot: import("react").FC<RadixTooltip.TooltipProps>;
+export declare const TooltipTrigger: import("react").ForwardRefExoticComponent<RadixTooltip.TooltipTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const TooltipContent: import("react").ForwardRefExoticComponent<Omit<RadixTooltip.TooltipContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/Tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export { Tooltip, TooltipProvider, TooltipRoot, TooltipTrigger, TooltipContent, } from './Tooltip';
+export type { TooltipProps } from './Tooltip';

package/dist/components/TreeView/RichTreeView.d.ts

@@ -0,0 +1,28 @@
+import type { ReactElement, ReactNode, Ref } from 'react';
+import type { TreeViewProps } from './TreeView';
+/** Minimal shape RichTreeView expects; extra fields are passed through untouched. */
+export type RichTreeViewItem = {
+    id?: string;
+    label?: ReactNode;
+    children?: RichTreeViewItem[];
+    [key: string]: unknown;
+};
+export interface RichTreeViewProps<T extends RichTreeViewItem = RichTreeViewItem> extends TreeViewProps {
+    /** Hierarchical data. */
+    items: T[];
+    /** Derive a stable id. Default `item.id`. */
+    getItemId?: (item: T) => string;
+    /** Derive the row label. Default `item.label`. */
+    getItemLabel?: (item: T) => ReactNode;
+    /** Derive child items. Default `item.children`. */
+    getItemChildren?: (item: T) => T[] | undefined;
+    /** Optional per-item leading icon. */
+    getItemIcon?: (item: T) => ReactNode;
+}
+/**
+ * Data-driven tree. Renders a `TreeView` from a `items` array; all expansion /
+ * selection props are forwarded to the underlying `TreeView`.
+ */
+export declare const RichTreeView: <T extends RichTreeViewItem = RichTreeViewItem>(props: RichTreeViewProps<T> & {
+    ref?: Ref<HTMLUListElement>;
+}) => ReactElement;

package/dist/components/TreeView/TreeView.d.ts

@@ -0,0 +1,31 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export interface TreeViewProps extends Omit<HTMLAttributes<HTMLUListElement>, 'onSelect'> {
+    /** Controlled set of expanded item ids. */
+    expandedIds?: string[];
+    /** Initial expanded ids when uncontrolled. */
+    defaultExpandedIds?: string[];
+    /** Fired with the next expanded ids whenever an item expands or collapses. */
+    onExpandedChange?: (ids: string[]) => void;
+    /** Controlled selected item id. */
+    selectedId?: string | null;
+    /** Initial selected id when uncontrolled. */
+    defaultSelectedId?: string | null;
+    /** Fired with the selected id. */
+    onSelectedChange?: (id: string) => void;
+    /** Fired when a specific item toggles — `(id, willExpand)`. Use for lazy loading. */
+    onItemExpandToggle?: (id: string, expanded: boolean) => void;
+    /** Auto folder/file icons for items without their own icon. Default `true`. */
+    defaultIcons?: boolean;
+}
+export declare const TreeView: import("react").ForwardRefExoticComponent<TreeViewProps & import("react").RefAttributes<HTMLUListElement>>;
+export interface TreeItemProps extends Omit<HTMLAttributes<HTMLLIElement>, 'id'> {
+    /** Stable id for this node. */
+    itemId: string;
+    /** Row label. */
+    label: ReactNode;
+    /** Optional leading icon. */
+    icon?: ReactNode;
+    /** Child TreeItems. */
+    children?: ReactNode;
+}
+export declare const TreeItem: import("react").ForwardRefExoticComponent<TreeItemProps & import("react").RefAttributes<HTMLLIElement>>;

package/dist/components/TreeView/index.d.ts

@@ -0,0 +1,4 @@
+export { TreeView, TreeItem } from './TreeView';
+export type { TreeViewProps, TreeItemProps } from './TreeView';
+export { RichTreeView } from './RichTreeView';
+export type { RichTreeViewProps, RichTreeViewItem } from './RichTreeView';