@godxjp/ui 13.9.3 → 13.10.0

package/dist/components/data-display/carousel.js

@@ -1,4 +1,220 @@
-export { Carousel, CarouselContent, CarouselDots, CarouselItem, CarouselNext, CarouselPrevious, useCarousel } from '../../chunk-NZBAFFWP.js';
-import '../../chunk-B6S6LTWT.js';
-import '../../chunk-5732TWQF.js';
-import '../../chunk-U7N2A7A3.js';
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import useEmblaCarousel from "embla-carousel-react";
+import { ChevronLeft, ChevronRight } from "lucide-react";
+import { useTranslation } from "../../i18n/use-translation";
+import { cn } from "../../lib/utils";
+const CarouselContext = React.createContext(null);
+const useCarousel = () => {
+  const context = React.useContext(CarouselContext);
+  if (!context) {
+    throw new Error("useCarousel must be used within a Carousel component");
+  }
+  return context;
+};
+const Carousel = React.forwardRef(({ className, opts, plugins, setApi, children, ...props }, ref) => {
+  const { t } = useTranslation();
+  const [emblaRef, api] = useEmblaCarousel(opts, plugins);
+  const [canScrollPrev, setCanScrollPrev] = React.useState(false);
+  const [canScrollNext, setCanScrollNext] = React.useState(false);
+  const [selectedIndex, setSelectedIndex] = React.useState(0);
+  const [scrollSnaps, setScrollSnaps] = React.useState([]);
+  const onSelect = React.useCallback(() => {
+    if (!api) return;
+    setCanScrollPrev(api.canScrollPrev());
+    setCanScrollNext(api.canScrollNext());
+    setSelectedIndex(api.selectedScrollSnap());
+  }, [api]);
+  React.useEffect(() => {
+    if (!api) return void 0;
+    onSelect();
+    setScrollSnaps(api.scrollSnapList());
+    setApi?.(api);
+    api.on("reInit", onSelect);
+    api.on("reInit", () => setScrollSnaps(api.scrollSnapList()));
+    api.on("select", onSelect);
+    return () => {
+      api.off("reInit", onSelect);
+      api.off("select", onSelect);
+    };
+  }, [api, onSelect, setApi]);
+  const scrollPrev = React.useCallback(() => {
+    api?.scrollPrev();
+  }, [api]);
+  const scrollNext = React.useCallback(() => {
+    api?.scrollNext();
+  }, [api]);
+  const scrollTo = React.useCallback(
+    (index) => {
+      api?.scrollTo(index);
+    },
+    [api]
+  );
+  const contextValue = React.useMemo(
+    () => ({
+      canScrollPrev,
+      canScrollNext,
+      selectedIndex,
+      scrollSnaps,
+      api,
+      scrollPrev,
+      scrollNext,
+      scrollTo
+    }),
+    [
+      canScrollPrev,
+      canScrollNext,
+      selectedIndex,
+      scrollSnaps,
+      api,
+      scrollPrev,
+      scrollNext,
+      scrollTo
+    ]
+  );
+  return /* @__PURE__ */ jsx(CarouselContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref,
+      "data-slot": "carousel",
+      className: cn("ui-carousel", className),
+      "data-orientation": opts?.axis === "y" ? "vertical" : "horizontal",
+      role: "region",
+      "aria-roledescription": t("dataDisplay.carousel.roleDescription"),
+      "aria-label": t("dataDisplay.carousel.ariaLabel"),
+      ...props,
+      children: /* @__PURE__ */ jsx("div", { className: "ui-carousel-viewport", ref: emblaRef, children })
+    }
+  ) });
+});
+Carousel.displayName = "Carousel";
+const CarouselContent = React.forwardRef(({ className, children, ...props }, ref) => {
+  const { t } = useTranslation();
+  const total = React.Children.toArray(children).filter(React.isValidElement).length;
+  let slideIndex = 0;
+  const decorated = React.Children.map(children, (child) => {
+    if (!React.isValidElement(child)) return child;
+    const index = slideIndex++;
+    const childProps = child.props;
+    if (childProps["aria-label"] != null) return child;
+    return React.cloneElement(child, {
+      "aria-label": t("dataDisplay.carousel.slideLabel", {
+        index: index + 1,
+        total
+      })
+    });
+  });
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref,
+      "data-slot": "carousel-content",
+      className: cn("ui-carousel-content", className),
+      ...props,
+      children: decorated
+    }
+  );
+});
+CarouselContent.displayName = "CarouselContent";
+const CarouselItem = React.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref,
+      "data-slot": "carousel-item",
+      role: "group",
+      "aria-roledescription": "slide",
+      className: cn("ui-carousel-item", className),
+      ...props
+    }
+  )
+);
+CarouselItem.displayName = "CarouselItem";
+const CarouselPrevious = React.forwardRef(({ className, ...props }, ref) => {
+  const { t } = useTranslation();
+  const { canScrollPrev, scrollPrev } = useCarousel();
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      ref,
+      type: "button",
+      "data-slot": "carousel-previous",
+      disabled: !canScrollPrev,
+      className: cn("ui-carousel-previous", className),
+      onClick: scrollPrev,
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx(ChevronLeft, { className: "ui-carousel-arrow", "aria-hidden": "true" }),
+        /* @__PURE__ */ jsx("span", { className: "sr-only", children: t("dataDisplay.carousel.previous") })
+      ]
+    }
+  );
+});
+CarouselPrevious.displayName = "CarouselPrevious";
+const CarouselNext = React.forwardRef(({ className, ...props }, ref) => {
+  const { t } = useTranslation();
+  const { canScrollNext, scrollNext } = useCarousel();
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      ref,
+      type: "button",
+      "data-slot": "carousel-next",
+      disabled: !canScrollNext,
+      className: cn("ui-carousel-next", className),
+      onClick: scrollNext,
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx(ChevronRight, { className: "ui-carousel-arrow", "aria-hidden": "true" }),
+        /* @__PURE__ */ jsx("span", { className: "sr-only", children: t("dataDisplay.carousel.next") })
+      ]
+    }
+  );
+});
+CarouselNext.displayName = "CarouselNext";
+const CarouselDots = React.forwardRef(
+  ({ className, ...props }, ref) => {
+    const { t } = useTranslation();
+    const { scrollSnaps, selectedIndex, scrollTo } = useCarousel();
+    if (scrollSnaps.length <= 1) return null;
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        "data-slot": "carousel-dots",
+        className: cn("ui-carousel-dots", className),
+        role: "tablist",
+        "aria-label": t("dataDisplay.carousel.dotsLabel"),
+        ...props,
+        children: scrollSnaps.map((_, index) => {
+          const active = index === selectedIndex;
+          return /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              role: "tab",
+              "data-slot": "carousel-dot",
+              "data-active": active ? "" : void 0,
+              className: "ui-carousel-dot",
+              "aria-selected": active,
+              "aria-current": active ? "true" : void 0,
+              "aria-label": t("dataDisplay.carousel.goToSlide", { index: index + 1 }),
+              onClick: () => scrollTo(index)
+            },
+            index
+          );
+        })
+      }
+    );
+  }
+);
+CarouselDots.displayName = "CarouselDots";
+export {
+  Carousel,
+  CarouselContent,
+  CarouselDots,
+  CarouselItem,
+  CarouselNext,
+  CarouselPrevious,
+  useCarousel
+};

package/dist/components/data-display/collapsible.d.ts

@@ -0,0 +1,4 @@
+import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
+export declare const Collapsible: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const CollapsibleTrigger: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const CollapsibleContent: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/data-display/collapsible.js

@@ -0,0 +1,9 @@
+import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
+const Collapsible = CollapsiblePrimitive.Root;
+const CollapsibleTrigger = CollapsiblePrimitive.CollapsibleTrigger;
+const CollapsibleContent = CollapsiblePrimitive.CollapsibleContent;
+export {
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger
+};

package/dist/components/data-display/data-table.d.ts

@@ -0,0 +1,53 @@
+import * as React from "react";
+import type { ColumnDefProp, TableDensityProp, SortStateProp } from "../../props/vocabulary";
+export type Density = TableDensityProp;
+export type ColumnDef<T> = ColumnDefProp<T>;
+interface DataTableProps<T> {
+    data: T[];
+    columns: ColumnDef<T>[];
+    /** Required when `selectable` is true. Default: assume row.id (typed as any). */
+    getRowId?: (row: T) => string;
+    selectable?: boolean;
+    selected?: Set<string>;
+    onSelectChange?: (next: Set<string>) => void;
+    onRowClick?: (row: T) => void;
+    density?: Density;
+    onDensityChange?: (d: Density) => void;
+    sort?: SortStateProp;
+    onSortChange?: (sort: SortStateProp | undefined) => void;
+    /** Show a loading row instead of data. */
+    loading?: boolean;
+    /** Custom empty content when `data` is empty; defaults to a built-in EmptyState. */
+    empty?: React.ReactNode;
+    className?: string;
+    children?: React.ReactNode;
+}
+export declare function DataTable<T>({ data, columns, getRowId, selectable, selected: controlledSelected, onSelectChange, onRowClick, density: controlledDensity, onDensityChange, sort, onSortChange, loading, empty, className, children, }: DataTableProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare namespace DataTable {
+    var Toolbar: ({ children, className, }: {
+        children?: React.ReactNode;
+        className?: string;
+    }) => import("react/jsx-runtime").JSX.Element;
+    var SelectAll: () => import("react/jsx-runtime").JSX.Element | null;
+    var BulkActions: ({ count, children, className, }: BulkActionsProps) => import("react/jsx-runtime").JSX.Element | null;
+    var DensityToggle: () => import("react/jsx-runtime").JSX.Element;
+    var Content: () => import("react/jsx-runtime").JSX.Element;
+    var Pagination: ({ cursor, hasMore, onChange, className, }: PaginationProps) => import("react/jsx-runtime").JSX.Element;
+    var RowActions: ({ ariaLabel, children }: RowActionsProps) => import("react/jsx-runtime").JSX.Element;
+}
+interface BulkActionsProps {
+    count?: number;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface PaginationProps {
+    cursor?: string;
+    hasMore: boolean;
+    onChange: (cursor: string | undefined) => void;
+    className?: string;
+}
+interface RowActionsProps {
+    ariaLabel?: string;
+    children: React.ReactNode;
+}
+export {};

package/dist/{chunk-NVTZ2EDW.js → components/data-display/data-table.js}

@@ -1,36 +1,27 @@
-import { EmptyState } from './chunk-YD7V2HGZ.js';
-import { Checkbox } from './chunk-BE6GJGKJ.js';
-import { Flex, densityClass } from './chunk-INIIF7F7.js';
-import { Button } from './chunk-XBFUROAY.js';
-import { Table, TableHeader, TableRow, TableHead, TableBody, TableCell } from './chunk-IJ5ALJGA.js';
-import { tableCellPaddingClass, tableRowHeightClass, controlIconSmClass } from './chunk-B4K4BXEF.js';
-import { useTranslation } from './chunk-B6S6LTWT.js';
-import { cn } from './chunk-U7N2A7A3.js';
-import { jsx, jsxs } from 'react/jsx-runtime';
-import * as React from 'react';
-import { Layers, Layers2, ArrowUp, ArrowDown, ChevronsUpDown, MoreHorizontal } from 'lucide-react';
-
-function Descriptions({ columns = 2, className, children }) {
-  const colsClass = columns === 1 ? "grid-cols-1" : columns === 3 ? "grid-cols-1 sm:grid-cols-2 lg:grid-cols-3" : "grid-cols-1 sm:grid-cols-2";
-  return /* @__PURE__ */ jsx("dl", { className: cn("grid gap-x-6 gap-y-3", colsClass, className), children });
-}
-Descriptions.Item = function DescriptionsItem({
-  label,
-  mono,
-  span,
-  className,
-  children
-}) {
-  const spanClass = span === 2 ? "sm:col-span-2" : span === 3 ? "sm:col-span-2 lg:col-span-3" : "";
-  return (
-    // grid + the shared --field-label-gap so the label→value gap matches FormField / Form everywhere.
-    /* @__PURE__ */ jsxs("div", { className: cn("grid gap-[var(--field-label-gap)]", spanClass, className), children: [
-      /* @__PURE__ */ jsx("dt", { className: "text-muted-foreground text-xs", children: label }),
-      /* @__PURE__ */ jsx("dd", { className: cn("text-sm break-all", mono && "font-mono"), children })
-    ] })
-  );
-};
-var DataTableContext = React.createContext(null);
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { ArrowDown, ArrowUp, ChevronsUpDown, Layers, Layers2, MoreHorizontal } from "lucide-react";
+import { useTranslation } from "../../i18n/use-translation";
+import { Flex } from "../layout/flex";
+import { Button } from "../general/button";
+import { EmptyState } from "./empty-state";
+import { Checkbox } from "../data-entry/checkbox";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow
+} from "../data-display/table";
+import { cn } from "../../lib/utils";
+import { densityClass } from "../../lib/variants";
+import {
+  controlIconSmClass,
+  tableCellPaddingClass,
+  tableRowHeightClass
+} from "../../lib/control-styles";
+const DataTableContext = React.createContext(null);
 function useDataTableContext() {
   const ctx = React.useContext(DataTableContext);
   if (!ctx) throw new Error("DataTable subcomponents must be used inside <DataTable>");
@@ -39,7 +30,7 @@ function useDataTableContext() {
 function useOptionalDataTableContext() {
   return React.useContext(DataTableContext);
 }
-var noopGetRowId = (row) => {
+const noopGetRowId = (row) => {
   const id = row.id;
   if (typeof id === "string") return id;
   if (typeof id === "number") return String(id);
@@ -385,5 +376,6 @@ DataTable.RowActions = function DataTableRowActions({ ariaLabel, children }) {
   );
 };
 DataTable.RowActions.displayName = "DataTable.RowActions";
-
-export { DataTable, Descriptions };
+export {
+  DataTable
+};

package/dist/components/data-display/descriptions.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+export interface DescriptionsProps {
+    columns?: 1 | 2 | 3;
+    className?: string;
+    children: React.ReactNode;
+}
+export declare function Descriptions({ columns, className, children }: DescriptionsProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Descriptions {
+    var Item: ({ label, mono, span, className, children, }: DescriptionsItemProps) => import("react/jsx-runtime").JSX.Element;
+}
+export interface DescriptionsItemProps {
+    label: React.ReactNode;
+    /** Use mono spacing for IDs, paths, JSON. */
+    mono?: boolean;
+    /** Span full row(s) when value is long. */
+    span?: 2 | 3;
+    className?: string;
+    children: React.ReactNode;
+}

package/dist/components/data-display/descriptions.js

@@ -0,0 +1,25 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { cn } from "../../lib/utils";
+function Descriptions({ columns = 2, className, children }) {
+  const colsClass = columns === 1 ? "grid-cols-1" : columns === 3 ? "grid-cols-1 sm:grid-cols-2 lg:grid-cols-3" : "grid-cols-1 sm:grid-cols-2";
+  return /* @__PURE__ */ jsx("dl", { className: cn("grid gap-x-6 gap-y-3", colsClass, className), children });
+}
+Descriptions.Item = function DescriptionsItem({
+  label,
+  mono,
+  span,
+  className,
+  children
+}) {
+  const spanClass = span === 2 ? "sm:col-span-2" : span === 3 ? "sm:col-span-2 lg:col-span-3" : "";
+  return (
+    // grid + the shared --field-label-gap so the label→value gap matches FormField / Form everywhere.
+    /* @__PURE__ */ jsxs("div", { className: cn("grid gap-[var(--field-label-gap)]", spanClass, className), children: [
+      /* @__PURE__ */ jsx("dt", { className: "text-muted-foreground text-xs", children: label }),
+      /* @__PURE__ */ jsx("dd", { className: cn("text-sm break-all", mono && "font-mono"), children })
+    ] })
+  );
+};
+export {
+  Descriptions
+};

package/dist/components/data-display/empty-state.d.ts

@@ -0,0 +1,3 @@
+import type { EmptyStateProp } from "../../props/components/data-display.prop";
+export type { EmptyStateProp, EmptyStateProp as EmptyStateProps, } from "../../props/components/data-display.prop";
+export declare function EmptyState({ icon: Icon, title, description, action, className }: EmptyStateProp): import("react/jsx-runtime").JSX.Element;

package/dist/{chunk-YD7V2HGZ.js → components/data-display/empty-state.js}

@@ -1,6 +1,5 @@
-import { cn } from './chunk-U7N2A7A3.js';
-import { jsxs, jsx } from 'react/jsx-runtime';
-
+import { jsx, jsxs } from "react/jsx-runtime";
+import { cn } from "../../lib/utils";
 function EmptyState({ icon: Icon, title, description, action, className }) {
   return /* @__PURE__ */ jsxs("div", { "data-slot": "empty-state", role: "status", className: cn("ui-empty-state", className), children: [
     Icon && /* @__PURE__ */ jsx("div", { className: "ui-empty-state-icon", children: /* @__PURE__ */ jsx(Icon, { className: "text-muted-foreground size-6", "aria-hidden": "true" }) }),
@@ -9,5 +8,6 @@ function EmptyState({ icon: Icon, title, description, action, className }) {
     action && /* @__PURE__ */ jsx("div", { children: action })
   ] });
 }
-
-export { EmptyState };
+export {
+  EmptyState
+};

package/dist/components/data-display/hover-card.d.ts

@@ -0,0 +1 @@
+export { HoverCard, HoverCardTrigger, HoverCardContent } from "../ui/hover-card";

package/dist/components/data-display/hover-card.js

@@ -0,0 +1,6 @@
+import { HoverCard, HoverCardTrigger, HoverCardContent } from "../ui/hover-card";
+export {
+  HoverCard,
+  HoverCardContent,
+  HoverCardTrigger
+};

package/dist/components/data-display/index.d.ts

@@ -1,79 +1,24 @@
-export { Badge, BadgeProps } from './badge.js';
-export { A as Avatar, a as AvatarFallback, b as AvatarImage } from '../../avatar-D9MdXzfF.js';
-export { Card, CardAction, CardContent, CardCover, CardDescription, CardFooter, CardHeader, CardTitle, StatCard, StatCardProps } from './card.js';
-export { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from './table.js';
-export { C as ColumnDef, D as DataTable, b as Descriptions, E as EmptyState, a as TableDensity } from '../../data-table-DRr70ULe.js';
-export { h as SortStateProp } from '../../interaction.prop-DD46aTro.js';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import * as React from 'react';
-import { ReactNode } from 'react';
-export { Popover, PopoverAnchor, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger } from './popover.js';
-export { ScrollArea, ScrollBar } from './scroll-area.js';
-import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
-import * as AccordionPrimitive from '@radix-ui/react-accordion';
-import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
-export { Carousel, CarouselApi, CarouselContent, CarouselDots, CarouselItem, CarouselNext, CarouselPrevious, useCarousel } from './carousel.js';
-import 'class-variance-authority/types';
-import 'class-variance-authority';
-import '@radix-ui/react-avatar';
-import '../../data-display.prop-CT0nVMdp.js';
-import '../../shared.prop-BvMSLFJ6.js';
-import '../../content.prop-DrV_zDy-.js';
-import '../../layout.prop-CXvl2rVR.js';
-import '../../data.prop-D0UEEczj.js';
-import '@radix-ui/react-popover';
-import '@radix-ui/react-scroll-area';
-import 'embla-carousel-react';
-
-type ProgressTone = "success" | "warning";
-type ProgressProps = {
-    value: number;
-    label?: string;
-    tone?: ProgressTone;
-};
-declare function Progress({ value, label, tone }: ProgressProps): react_jsx_runtime.JSX.Element;
-
-type TreeListItem = {
-    id: string;
-    title: ReactNode;
-    description?: ReactNode;
-    depth?: number;
-    active?: boolean;
-    badge?: ReactNode;
-};
-type TreeListProps = {
-    items: TreeListItem[];
-};
-declare function TreeList({ items }: TreeListProps): react_jsx_runtime.JSX.Element;
-
-type TimelineItem = {
-    title: ReactNode;
-    location?: ReactNode;
-    time?: ReactNode;
-    note?: ReactNode;
-    current?: boolean;
-};
-type TimelineProps = {
-    items: TimelineItem[];
-};
-declare function Timeline({ items }: TimelineProps): react_jsx_runtime.JSX.Element;
-
-declare const Collapsible: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & React.RefAttributes<HTMLDivElement>>;
-declare const CollapsibleTrigger: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const CollapsibleContent: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & React.RefAttributes<HTMLDivElement>>;
-
-declare const Accordion: React.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React.RefAttributes<HTMLDivElement>>;
-declare const AccordionItem: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const AccordionTrigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-declare const AccordionContent: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-
-/**
- * HoverCard root. Defaults to a SNAPPY 200ms open / 100ms close (Radix's raw 700/300 default felt
- * laggy); consumers can still pass `openDelay`/`closeDelay`. A small open delay (not 0) is
- * intentional — it prevents accidental triggering as the pointer passes over the trigger.
- */
-declare function HoverCard({ openDelay, closeDelay, ...props }: React.ComponentProps<typeof HoverCardPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare const HoverCardTrigger: React.ForwardRefExoticComponent<HoverCardPrimitive.HoverCardTriggerProps & React.RefAttributes<HTMLAnchorElement>>;
-declare const HoverCardContent: React.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-
-export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Collapsible, CollapsibleContent, CollapsibleTrigger, HoverCard, HoverCardContent, HoverCardTrigger, Progress, type ProgressProps, type ProgressTone, Timeline, type TimelineItem, type TimelineProps, TreeList, type TreeListItem, type TreeListProps };
+export { Badge } from "./badge";
+export type { BadgeProps } from "./badge";
+export { Avatar, AvatarImage, AvatarFallback } from "./avatar";
+export { Card, CardContent, CardCover, CardDescription, CardFooter, CardHeader, CardTitle, CardAction, StatCard, } from "./card";
+export type { StatCardProps } from "./card";
+export { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "./table";
+export { Descriptions } from "./descriptions";
+export { DataTable } from "./data-table";
+export type { ColumnDef, Density as TableDensity } from "./data-table";
+export type { SortStateProp } from "../../props/vocabulary";
+export { EmptyState } from "./empty-state";
+export { Progress } from "./progress";
+export type { ProgressProps, ProgressTone } from "./progress";
+export { TreeList } from "./tree-list";
+export type { TreeListItem, TreeListProps } from "./tree-list";
+export { Timeline } from "./timeline";
+export type { TimelineItem, TimelineProps } from "./timeline";
+export { Popover, PopoverAnchor, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger, } from "./popover";
+export { ScrollArea, ScrollBar } from "./scroll-area";
+export { Collapsible, CollapsibleTrigger, CollapsibleContent } from "./collapsible";
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent } from "./accordion";
+export { HoverCard, HoverCardTrigger, HoverCardContent } from "./hover-card";
+export { Carousel, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious, CarouselDots, useCarousel, } from "./carousel";
+export type { CarouselApi } from "./carousel";