@assure-one/design-system 0.1.1 → 0.4.0

package/dist/index.d.ts

@@ -1,185 +1,222 @@
 export { ColorName, ReferenceTokens, SystemTokens, colors, radii, reference, shadows, spacing, surfaces, systemTokens, typography } from './tokens/index.js';
+import * as React$1 from 'react';
+import { ReactNode } from 'react';
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import * as react from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as AspectRatioPrimitive from '@radix-ui/react-aspect-ratio';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+import { DayPickerProps } from 'react-day-picker';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as ProgressPrimitive from '@radix-ui/react-progress';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as SliderPrimitive from '@radix-ui/react-slider';
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as VisuallyHiddenPrimitive from '@radix-ui/react-visually-hidden';
 import { ClassValue } from 'clsx';
 
-interface AccordionProps extends React.HTMLAttributes<HTMLDivElement> {
-    type?: "single" | "multiple";
-    defaultValue?: string[];
-    value?: string[];
-    onValueChange?: (value: string[]) => void;
-}
-declare function Accordion({ type, defaultValue, value: controlledValue, onValueChange, children, className, ...props }: AccordionProps): react_jsx_runtime.JSX.Element;
-interface AccordionItemProps extends React.HTMLAttributes<HTMLDivElement> {
-    value: string;
-}
-declare function AccordionItem({ value, children, className, ...props }: AccordionItemProps): react_jsx_runtime.JSX.Element;
-type AccordionTriggerProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
-declare function AccordionTrigger({ children, className, ...props }: AccordionTriggerProps): react_jsx_runtime.JSX.Element;
-type AccordionContentProps = React.HTMLAttributes<HTMLDivElement>;
-declare function AccordionContent({ children, className, ...props }: AccordionContentProps): react_jsx_runtime.JSX.Element;
-
-interface AlertDialogProps {
-    children: React.ReactNode;
-    open?: boolean;
-    onOpenChange?: (open: boolean) => void;
-}
-declare function AlertDialog({ children, open: controlledOpen, onOpenChange, }: AlertDialogProps): react_jsx_runtime.JSX.Element;
-type AlertDialogTriggerProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
-declare function AlertDialogTrigger({ children, className, ...props }: AlertDialogTriggerProps): react_jsx_runtime.JSX.Element;
-type AlertDialogContentProps = React.HTMLAttributes<HTMLDivElement>;
-declare function AlertDialogContent({ children, className, ...props }: AlertDialogContentProps): react.ReactPortal | null;
-type AlertDialogHeaderProps = React.HTMLAttributes<HTMLDivElement>;
-declare function AlertDialogHeader({ className, ...props }: AlertDialogHeaderProps): react_jsx_runtime.JSX.Element;
-type AlertDialogTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
-declare function AlertDialogTitle({ className, ...props }: AlertDialogTitleProps): react_jsx_runtime.JSX.Element;
-type AlertDialogDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
-declare function AlertDialogDescription({ className, ...props }: AlertDialogDescriptionProps): react_jsx_runtime.JSX.Element;
-type AlertDialogFooterProps = React.HTMLAttributes<HTMLDivElement>;
-declare function AlertDialogFooter({ className, ...props }: AlertDialogFooterProps): react_jsx_runtime.JSX.Element;
-type AlertDialogActionProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
-declare function AlertDialogAction({ children, className, ...props }: AlertDialogActionProps): react_jsx_runtime.JSX.Element;
-type AlertDialogCancelProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
-declare function AlertDialogCancel({ children, className, ...props }: AlertDialogCancelProps): react_jsx_runtime.JSX.Element;
-
-declare const variantStyles$4: {
-    readonly info: "border-blue-200 bg-blue-50 text-blue-link [&_svg]:text-blue-link";
-    readonly success: "border-green-light-border bg-green-lighter-bg text-green-action [&_svg]:text-green-action";
-    readonly warning: "border-yellow-200 bg-amber-50 text-amber-dark [&_svg]:text-amber-dark";
-    readonly destructive: "border-red-200 bg-red-50 text-red-action [&_svg]:text-red-action";
+type AccordionProps = React$1.ComponentPropsWithoutRef<typeof AccordionPrimitive.Root>;
+declare const Accordion: React$1.ForwardRefExoticComponent<AccordionProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const AlertDialog: React$1.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: React$1.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: React$1.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
 };
-interface AlertProps extends React.HTMLAttributes<HTMLDivElement> {
-    variant?: keyof typeof variantStyles$4;
+declare const AlertDialogTitle: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Alert — inline banner. Variants align with the three Assure status families
+ * (success, warning, danger) plus a cyan-accent `info` (per spec §3 — three
+ * statuses, not five).
+ */
+declare const alertVariants: (props?: ({
+    variant?: "info" | "success" | "warning" | "destructive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AlertProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof alertVariants> {
 }
-declare function Alert({ variant, children, className, ...props }: AlertProps): react_jsx_runtime.JSX.Element;
-type AlertTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
-declare function AlertTitle({ className, ...props }: AlertTitleProps): react_jsx_runtime.JSX.Element;
-type AlertDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
-declare function AlertDescription({ className, ...props }: AlertDescriptionProps): react_jsx_runtime.JSX.Element;
+declare const Alert: React$1.ForwardRefExoticComponent<AlertProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
 
-interface AspectRatioProps extends React.HTMLAttributes<HTMLDivElement> {
+interface AspectRatioProps extends React$1.ComponentPropsWithoutRef<typeof AspectRatioPrimitive.Root> {
     ratio?: number;
-    children: React.ReactNode;
+    children: React$1.ReactNode;
 }
-declare function AspectRatio({ ratio, children, className, ...props }: AspectRatioProps): react_jsx_runtime.JSX.Element;
+declare const AspectRatio: React$1.ForwardRefExoticComponent<AspectRatioProps & React$1.RefAttributes<HTMLDivElement>>;
 
-declare const sizeStyles$5: {
-    readonly xs: "size-5 text-[10px]";
-    readonly sm: "size-8 text-xs";
-    readonly md: "size-10 text-sm";
-    readonly lg: "size-14 text-base";
-};
+declare const avatarVariants: (props?: ({
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    variant?: "initials" | "branded" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
 declare const statusStyles: {
-    readonly online: "bg-success";
-    readonly offline: "bg-app-gray-400";
-    readonly busy: "bg-destructive";
+    readonly online: "bg-success-fg";
+    readonly away: "bg-warning-fg";
+    readonly busy: "bg-danger-fg";
+    readonly offline: "bg-fg-4";
 };
-interface AvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+interface AvatarProps extends Omit<React$1.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>, "children">, VariantProps<typeof avatarVariants> {
     src?: string | null;
     alt?: string;
     name?: string;
-    size?: keyof typeof sizeStyles$5;
     status?: keyof typeof statusStyles;
 }
-declare function Avatar({ src, alt, name, size, status, className, ...props }: AvatarProps): react_jsx_runtime.JSX.Element;
+declare const Avatar: React$1.ForwardRefExoticComponent<AvatarProps & React$1.RefAttributes<HTMLSpanElement>>;
 
-declare const variantStyles$3: {
-    readonly default: "bg-primary text-primary-foreground";
-    readonly secondary: "bg-secondary text-secondary-foreground";
-    readonly destructive: "bg-destructive/10 text-destructive";
-    readonly success: "bg-green-badge-bg text-green-action";
-    readonly warning: "bg-amber-50 text-amber-dark";
-    readonly info: "bg-blue-50 text-blue-link";
-    readonly outline: "border border-border bg-transparent text-foreground";
-};
-declare const sizeStyles$4: {
-    readonly sm: "px-2 py-0.5 text-xs";
-    readonly md: "px-2.5 py-0.5 text-sm";
-};
-interface BadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
-    variant?: keyof typeof variantStyles$3;
-    size?: keyof typeof sizeStyles$4;
+/**
+ * Badge — status atom. Variants port the `.pill` family in `_shared.css`
+ * (lines 257-289). Default variant is the neutral pill.
+ */
+declare const badgeVariants: (props?: ({
+    variant?: "info" | "success" | "warning" | "destructive" | "default" | "secondary" | "outline" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof badgeVariants> {
     dot?: boolean;
     icon?: React.ReactNode;
 }
-declare function Badge({ variant, size, dot, icon, children, className, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+declare const Badge: React$1.ForwardRefExoticComponent<BadgeProps & React$1.RefAttributes<HTMLSpanElement>>;
 
+/**
+ * Blockquote — semantic quote with optional attribution. Uses `font-display`
+ * (Geist) at a comfortable reading scale; smart quotes are wrapped automatically.
+ */
 interface BlockquoteProps extends React.BlockquoteHTMLAttributes<HTMLQuoteElement> {
     author?: string;
     role?: string;
 }
-declare function Blockquote({ children, author, role: authorRole, className, ...props }: BlockquoteProps): react_jsx_runtime.JSX.Element;
+declare const Blockquote: React$1.ForwardRefExoticComponent<BlockquoteProps & React$1.RefAttributes<HTMLQuoteElement>>;
 
+/**
+ * Breadcrumb — semantic navigation primitive. Uses the catalog `ChevronRightIcon` as the
+ * default separator. Current page (BreadcrumbPage) leans on Pro purple to
+ * mirror the active-state language used elsewhere in the firm app.
+ *
+ * Public API preserved: Breadcrumb / BreadcrumbList / BreadcrumbItem /
+ * BreadcrumbLink / BreadcrumbPage / BreadcrumbSeparator.
+ */
 type BreadcrumbProps = React.HTMLAttributes<HTMLElement>;
-declare function Breadcrumb({ className, ...props }: BreadcrumbProps): react_jsx_runtime.JSX.Element;
+declare const Breadcrumb: React$1.ForwardRefExoticComponent<BreadcrumbProps & React$1.RefAttributes<HTMLElement>>;
 type BreadcrumbListProps = React.HTMLAttributes<HTMLOListElement>;
-declare function BreadcrumbList({ className, ...props }: BreadcrumbListProps): react_jsx_runtime.JSX.Element;
+declare const BreadcrumbList: React$1.ForwardRefExoticComponent<BreadcrumbListProps & React$1.RefAttributes<HTMLOListElement>>;
 type BreadcrumbItemProps = React.HTMLAttributes<HTMLLIElement>;
-declare function BreadcrumbItem({ className, ...props }: BreadcrumbItemProps): react_jsx_runtime.JSX.Element;
+declare const BreadcrumbItem: React$1.ForwardRefExoticComponent<BreadcrumbItemProps & React$1.RefAttributes<HTMLLIElement>>;
 type BreadcrumbLinkProps = React.AnchorHTMLAttributes<HTMLAnchorElement>;
-declare function BreadcrumbLink({ className, ...props }: BreadcrumbLinkProps): react_jsx_runtime.JSX.Element;
+declare const BreadcrumbLink: React$1.ForwardRefExoticComponent<BreadcrumbLinkProps & React$1.RefAttributes<HTMLAnchorElement>>;
 type BreadcrumbPageProps = React.HTMLAttributes<HTMLSpanElement>;
-declare function BreadcrumbPage({ className, ...props }: BreadcrumbPageProps): react_jsx_runtime.JSX.Element;
+declare const BreadcrumbPage: React$1.ForwardRefExoticComponent<BreadcrumbPageProps & React$1.RefAttributes<HTMLSpanElement>>;
 type BreadcrumbSeparatorProps = React.HTMLAttributes<HTMLSpanElement>;
-declare function BreadcrumbSeparator({ children, className, ...props }: BreadcrumbSeparatorProps): react_jsx_runtime.JSX.Element;
-
-declare const variantStyles$2: {
-    readonly primary: "bg-primary text-primary-foreground hover:bg-primary/90";
-    readonly secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80";
-    readonly destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90";
-    readonly success: "bg-green-action text-success-foreground hover:bg-green-dark";
-    readonly ghost: "hover:bg-accent hover:text-accent-foreground";
-    readonly outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground";
-    readonly link: "text-primary underline-offset-4 hover:underline";
-};
-declare const sizeStyles$3: {
-    readonly sm: "h-8 px-3 text-sm gap-1.5";
-    readonly md: "h-10 px-4 text-sm gap-2";
-    readonly lg: "h-12 px-6 text-base gap-2";
-    readonly icon: "size-10";
-};
-interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
-    variant?: keyof typeof variantStyles$2;
-    size?: keyof typeof sizeStyles$3;
+declare const BreadcrumbSeparator: React$1.ForwardRefExoticComponent<BreadcrumbSeparatorProps & React$1.RefAttributes<HTMLSpanElement>>;
+
+/**
+ * Button — Assure Pro action atom.
+ *
+ * Variants port the `.btn-*` rules in `_shared.css` (lines 164-203):
+ *   - primary    → bg-pro-fg (Pro purple, the firm app's brand identity)
+ *   - secondary  → ghost surface bg-bg-2
+ *   - destructive → bg-danger-fg
+ *   - success    → bg-success-fg
+ *   - ghost      → transparent, hover:bg-bg-2
+ *   - outline    → bordered surface (matches `.btn-ghost` from spec)
+ *   - link       → text-accent (cyan) with underline-on-hover
+ *   - accent     → bg-accent (cyan CTA per spec §6.2)
+ *
+ * Sizes match shadcn convention; default `md` matches spec's 8px/14px padding.
+ * Use `asChild` to render as a different element (e.g. an anchor / next/link).
+ */
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "success" | "destructive" | "secondary" | "outline" | "primary" | "ghost" | "accent" | null | undefined;
+    size?: "sm" | "md" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    /** Render as the child element via Radix `Slot` (shadcn pattern). */
+    asChild?: boolean;
     loading?: boolean;
     iconLeft?: React.ReactNode;
     iconRight?: React.ReactNode;
 }
-declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
 
+type CalendarHighlightColor = "primary" | "success" | "warning" | "destructive";
 interface CalendarHighlight {
     date: Date;
-    color?: "primary" | "success" | "warning" | "destructive";
+    color?: CalendarHighlightColor;
 }
-interface CalendarProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onSelect"> {
+interface CalendarProps extends Omit<DayPickerProps, "mode" | "selected" | "onSelect" | "modifiers" | "modifiersClassNames"> {
     selected?: Date | null;
     onSelect?: (date: Date) => void;
     highlights?: CalendarHighlight[];
     minDate?: Date;
     maxDate?: Date;
+    className?: string;
+}
+declare function Calendar({ selected, onSelect, highlights, minDate, maxDate, className, classNames, ...props }: CalendarProps): react_jsx_runtime.JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
 }
-declare function Calendar({ selected, onSelect, highlights, minDate, maxDate, className, ...props }: CalendarProps): react_jsx_runtime.JSX.Element;
-
-type CardProps = React.HTMLAttributes<HTMLDivElement>;
-declare function Card({ className, ...props }: CardProps): react_jsx_runtime.JSX.Element;
-type CardHeaderProps = React.HTMLAttributes<HTMLDivElement>;
-declare function CardHeader({ className, ...props }: CardHeaderProps): react_jsx_runtime.JSX.Element;
-type CardTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
-declare function CardTitle({ className, ...props }: CardTitleProps): react_jsx_runtime.JSX.Element;
-type CardDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
-declare function CardDescription({ className, ...props }: CardDescriptionProps): react_jsx_runtime.JSX.Element;
-type CardContentProps = React.HTMLAttributes<HTMLDivElement>;
-declare function CardContent({ className, ...props }: CardContentProps): react_jsx_runtime.JSX.Element;
-type CardFooterProps = React.HTMLAttributes<HTMLDivElement>;
-declare function CardFooter({ className, ...props }: CardFooterProps): react_jsx_runtime.JSX.Element;
-type CardActionProps = React.HTMLAttributes<HTMLDivElement>;
-declare function CardAction({ className, ...props }: CardActionProps): react_jsx_runtime.JSX.Element;
-
-interface CheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type"> {
+
+/**
+ * Card — surface container. Default surfaces use the `.surface` rule from
+ * `_shared.css` (12px radius, 1px rule border, surface bg). Three variants:
+ *
+ *   default     — settled card on the page (current behavior, unchanged)
+ *   interactive — clickable card; hover darkens the border
+ *   flat        — borderless / shadowless transparent surface, for nesting
+ *                 inside Dialog/Sheet/Card without double-border
+ */
+declare const cardVariants: (props?: ({
+    variant?: "flat" | "default" | "interactive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type CardVariants = VariantProps<typeof cardVariants>;
+interface CardProps extends React.HTMLAttributes<HTMLDivElement>, CardVariants {
+}
+declare const Card: React$1.ForwardRefExoticComponent<CardProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const CardDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardAction: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+
+interface CheckboxProps extends Omit<React$1.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>, "checked" | "defaultChecked"> {
+    /** Optional inline label rendered to the right of the box */
     label?: string;
+    /** Tri-state support: true | false | "indeterminate" */
+    checked?: boolean | "indeterminate";
+    defaultChecked?: boolean | "indeterminate";
+    /** Convenience: render with indeterminate state. Mirrors legacy prop. */
     indeterminate?: boolean;
 }
-declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;
+declare const Checkbox: React$1.ForwardRefExoticComponent<CheckboxProps & React$1.RefAttributes<HTMLButtonElement>>;
 
 type ClientSelectOption = {
     id: string;
@@ -196,32 +233,34 @@ interface ClientSelectProps {
     placeholder?: string;
 }
 declare function ClientSelect({ clients, value, onChange, name, error, className, placeholder, }: ClientSelectProps): react_jsx_runtime.JSX.Element;
-
-interface CollapsibleProps extends React.HTMLAttributes<HTMLDivElement> {
-    open?: boolean;
-    defaultOpen?: boolean;
-    onOpenChange?: (open: boolean) => void;
+declare namespace ClientSelect {
+    var displayName: string;
 }
-declare function Collapsible({ open: controlledOpen, defaultOpen, onOpenChange, children, className, ...props }: CollapsibleProps): react_jsx_runtime.JSX.Element;
-type CollapsibleTriggerProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
-declare function CollapsibleTrigger({ children, className, ...props }: CollapsibleTriggerProps): react_jsx_runtime.JSX.Element;
-type CollapsibleContentProps = React.HTMLAttributes<HTMLDivElement>;
-declare function CollapsibleContent({ children, className, ...props }: CollapsibleContentProps): react_jsx_runtime.JSX.Element;
 
+declare const Collapsible: React$1.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: React$1.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: React$1.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * ComingSoon — placeholder pattern for unreleased modules. Pro-tinted icon
+ * halo, dashed Assure border, "In Development" pill.
+ *
+ * Public API preserved: `icon`, `title`, `description`, `features`.
+ */
 interface ComingSoonProps extends React.HTMLAttributes<HTMLDivElement> {
     icon: React.ReactNode;
     title: string;
     description: string;
     features: string[];
 }
-declare function ComingSoon({ icon, title, description, features, className, ...props }: ComingSoonProps): react_jsx_runtime.JSX.Element;
+declare const ComingSoon: React$1.ForwardRefExoticComponent<ComingSoonProps & React$1.RefAttributes<HTMLDivElement>>;
 
 interface CommandItem {
     id: string;
     label: string;
     description?: string;
     group?: string;
-    icon?: React.ReactNode;
+    icon?: React$1.ReactNode;
     shortcut?: string;
     onSelect: () => void;
     keywords?: string[];
@@ -233,38 +272,62 @@ interface CommandPaletteProps {
     placeholder?: string;
 }
 
-declare function CommandPalette({ items, open: controlledOpen, onOpenChange, placeholder, }: CommandPaletteProps): react.ReactPortal | null;
+declare function CommandPalette({ items, open: controlledOpen, onOpenChange, placeholder, }: CommandPaletteProps): react_jsx_runtime.JSX.Element;
 
-interface ContextMenuProps {
-    children: React.ReactNode;
-}
-declare function ContextMenu({ children }: ContextMenuProps): react_jsx_runtime.JSX.Element;
-interface ContextMenuTriggerProps extends React.HTMLAttributes<HTMLDivElement> {
-    children: React.ReactNode;
-}
-declare function ContextMenuTrigger({ children, className, onContextMenu, ...rest }: ContextMenuTriggerProps): react_jsx_runtime.JSX.Element;
-interface ContextMenuContentProps extends React.HTMLAttributes<HTMLDivElement> {
-    children: React.ReactNode;
-}
-declare function ContextMenuContent({ children, className, ...props }: ContextMenuContentProps): react_jsx_runtime.JSX.Element | null;
-interface ContextMenuItemProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+interface ConfirmActionButtonProps {
+    /** Element rendered as the dialog trigger via `<AlertDialogTrigger asChild>`. */
+    trigger: React$1.ReactNode;
+    title: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    confirmLabel?: React$1.ReactNode;
+    cancelLabel?: React$1.ReactNode;
+    /** Awaited; dialog closes after resolve, stays open on reject. */
+    onConfirm: () => void | Promise<void>;
+    /** When true (default) the Action button uses the destructive palette;
+     *  when false it uses the Pro primary palette (bg-pro-fg). */
     destructive?: boolean;
-}
-declare function ContextMenuItem({ destructive, children, className, onClick, ...rest }: ContextMenuItemProps): react_jsx_runtime.JSX.Element;
-type ContextMenuSeparatorProps = React.HTMLAttributes<HTMLDivElement>;
-declare function ContextMenuSeparator({ className, ...props }: ContextMenuSeparatorProps): react_jsx_runtime.JSX.Element;
+    /** Forwarded to AlertDialogContent for one-off layout overrides. */
+    contentClassName?: string;
+}
+declare function ConfirmActionButton({ trigger, title, description, confirmLabel, cancelLabel, onConfirm, destructive, contentClassName, }: ConfirmActionButtonProps): react_jsx_runtime.JSX.Element;
+
+declare const ContextMenu: React$1.FC<ContextMenuPrimitive.ContextMenuProps>;
+declare const ContextMenuTrigger: React$1.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React$1.RefAttributes<HTMLSpanElement>>;
+declare const ContextMenuGroup: React$1.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuPortal: React$1.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
+declare const ContextMenuSub: React$1.FC<ContextMenuPrimitive.ContextMenuSubProps>;
+declare const ContextMenuRadioGroup: React$1.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubContent: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuContent: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+interface ContextMenuItemProps extends React$1.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Item> {
+    destructive?: boolean;
+    inset?: boolean;
+}
+declare const ContextMenuItem: React$1.ForwardRefExoticComponent<ContextMenuItemProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuLabel: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSeparator: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuShortcut: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
 
 interface CopyButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
     value: string;
     feedbackDuration?: number;
 }
-declare function CopyButton({ value, feedbackDuration, className, children, ...props }: CopyButtonProps): react_jsx_runtime.JSX.Element;
-
 /**
- * Single shared date picker. Displays MM/DD/YYYY everywhere; reads & emits
- * ISO YYYY-MM-DD via `value` / `onChange` / hidden form input so it is a
- * drop-in replacement for the previous native `<input type="date">`.
+ * CopyButton — single-click clipboard copy with check-mark feedback.
+ * Renders the lucide `Copy` icon by default; pass `children` to override.
  */
+declare const CopyButton: React$1.ForwardRefExoticComponent<CopyButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+
 interface DatePickerProps {
     value?: string;
     defaultValue?: string;
@@ -290,68 +353,90 @@ interface DatePickerProps {
 declare const DATE_DISPLAY_PLACEHOLDER = "MM/DD/YYYY";
 declare function isoToDisplay(iso: string | undefined | null): string;
 declare function displayToIso(display: string): string;
-declare const DatePicker: react.ForwardRefExoticComponent<DatePickerProps & react.RefAttributes<HTMLInputElement>>;
+declare const DatePicker: React$1.ForwardRefExoticComponent<DatePickerProps & React$1.RefAttributes<HTMLInputElement>>;
 
-interface DialogProps {
-    children: React.ReactNode;
-    open?: boolean;
-    onOpenChange?: (open: boolean) => void;
-}
-declare function Dialog({ children, open: controlledOpen, onOpenChange, }: DialogProps): react_jsx_runtime.JSX.Element;
-type DialogTriggerProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
-declare function DialogTrigger({ children, className, ...props }: DialogTriggerProps): react_jsx_runtime.JSX.Element;
-declare const sizeStyles$2: {
+declare const Dialog: React$1.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const dialogSizeStyles: {
     readonly sm: "max-w-sm";
     readonly md: "max-w-lg";
     readonly lg: "max-w-2xl";
     readonly full: "max-w-[calc(100vw-2rem)]";
 };
-interface DialogContentProps extends React.HTMLAttributes<HTMLDivElement> {
-    size?: keyof typeof sizeStyles$2;
-}
-declare function DialogContent({ size, children, className, ...props }: DialogContentProps): react.ReactPortal | null;
-type DialogHeaderProps = React.HTMLAttributes<HTMLDivElement>;
-declare function DialogHeader({ className, ...props }: DialogHeaderProps): react_jsx_runtime.JSX.Element;
-type DialogTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
-declare function DialogTitle({ className, ...props }: DialogTitleProps): react_jsx_runtime.JSX.Element;
-type DialogDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
-declare function DialogDescription({ className, ...props }: DialogDescriptionProps): react_jsx_runtime.JSX.Element;
-type DialogFooterProps = React.HTMLAttributes<HTMLDivElement>;
-declare function DialogFooter({ className, ...props }: DialogFooterProps): react_jsx_runtime.JSX.Element;
-type DialogCloseProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
-declare function DialogClose({ children, className, ...props }: DialogCloseProps): react_jsx_runtime.JSX.Element;
-
-interface DropdownMenuProps {
-    children: React.ReactNode;
-    open?: boolean;
-    onOpenChange?: (open: boolean) => void;
-}
-declare function DropdownMenu({ children, open: controlledOpen, onOpenChange, }: DropdownMenuProps): react_jsx_runtime.JSX.Element;
-type DropdownMenuTriggerProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
-declare function DropdownMenuTrigger({ children, className, onClick, ...rest }: DropdownMenuTriggerProps): react_jsx_runtime.JSX.Element;
-interface DropdownMenuContentProps extends React.HTMLAttributes<HTMLDivElement> {
-    align?: "start" | "center" | "end";
-    side?: "bottom" | "top";
+interface DialogContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
+    size?: keyof typeof dialogSizeStyles;
+    /**
+     * If false, the built-in close button is hidden. Default: true.
+     * Use `<DialogClose>` inside content to render your own close UI.
+     */
+    showCloseButton?: boolean;
 }
-declare function DropdownMenuContent({ align, side, children, className, ...props }: DropdownMenuContentProps): react.ReactPortal | null;
-interface DropdownMenuItemProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+declare const DialogContent: React$1.ForwardRefExoticComponent<DialogContentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogClose: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const chipVariants: (props?: ({
+    variant?: "primary" | "neutral" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface DismissibleChipProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "onClick" | "children">, VariantProps<typeof chipVariants> {
+    label: React$1.ReactNode;
+    onDismiss: () => void;
+}
+declare const DismissibleChip: React$1.ForwardRefExoticComponent<DismissibleChipProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const DropdownMenu: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React$1.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuItemProps extends React$1.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> {
+    /** Render as a destructive (danger) action. */
     destructive?: boolean;
-}
-declare function DropdownMenuItem({ destructive, children, className, onClick, ...rest }: DropdownMenuItemProps): react_jsx_runtime.JSX.Element;
-type DropdownMenuSeparatorProps = React.HTMLAttributes<HTMLDivElement>;
-declare function DropdownMenuSeparator({ className, ...props }: DropdownMenuSeparatorProps): react_jsx_runtime.JSX.Element;
-type DropdownMenuLabelProps = React.HTMLAttributes<HTMLDivElement>;
-declare function DropdownMenuLabel({ className, ...props }: DropdownMenuLabelProps): react_jsx_runtime.JSX.Element;
-type DropdownMenuGroupProps = React.HTMLAttributes<HTMLDivElement>;
-declare function DropdownMenuGroup({ className, ...props }: DropdownMenuGroupProps): react_jsx_runtime.JSX.Element;
+    /** Increase left padding to align with checkbox/radio items. */
+    inset?: boolean;
+}
+declare const DropdownMenuItem: React$1.ForwardRefExoticComponent<DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
 
+/**
+ * EmptyState — restated with Assure Pro tokens. Display headline (Geist),
+ * fg-3 description, neutral icon halo on bg-2.
+ *
+ * Public API preserved: `icon`, `title`, `description`, `action`.
+ */
 interface EmptyStateProps extends React.HTMLAttributes<HTMLDivElement> {
     icon?: React.ReactNode;
     title: string;
     description?: string;
     action?: React.ReactNode;
 }
-declare function EmptyState({ icon, title, description, action, className, ...props }: EmptyStateProps): react_jsx_runtime.JSX.Element;
+declare const EmptyState: React$1.ForwardRefExoticComponent<EmptyStateProps & React$1.RefAttributes<HTMLDivElement>>;
 
 interface FileUploadProps extends React.HTMLAttributes<HTMLDivElement> {
     accept?: string;
@@ -365,25 +450,24 @@ declare function FileUpload({ accept, maxSize, multiple, onFilesSelected, disabl
 interface FormErrorProps extends React.HTMLAttributes<HTMLParagraphElement> {
     children: React.ReactNode;
 }
+/**
+ * Inline form error — paired below an input to communicate validation failure.
+ * Uses architectural --color-danger-fg token.
+ */
 declare function FormError({ children, className, ...props }: FormErrorProps): react_jsx_runtime.JSX.Element;
 interface FormSuccessProps extends React.HTMLAttributes<HTMLParagraphElement> {
     children: React.ReactNode;
 }
+/**
+ * Inline form success — paired below an input to confirm a saved value.
+ * Uses architectural --color-success-fg token.
+ */
 declare function FormSuccess({ children, className, ...props }: FormSuccessProps): react_jsx_runtime.JSX.Element;
 
-interface HoverCardProps {
-    children: React.ReactNode;
-    openDelay?: number;
-    closeDelay?: number;
-}
-declare function HoverCard({ children, openDelay, closeDelay, }: HoverCardProps): react_jsx_runtime.JSX.Element;
-type HoverCardTriggerProps = React.HTMLAttributes<HTMLSpanElement>;
-declare function HoverCardTrigger({ children, className, ...props }: HoverCardTriggerProps): react_jsx_runtime.JSX.Element;
-interface HoverCardContentProps extends React.HTMLAttributes<HTMLDivElement> {
-    side?: "top" | "bottom";
-    align?: "start" | "center" | "end";
-}
-declare function HoverCardContent({ side, align, children, className, ...props }: HoverCardContentProps): react_jsx_runtime.JSX.Element | null;
+declare const HoverCard: React$1.FC<HoverCardPrimitive.HoverCardProps>;
+declare const HoverCardTrigger: React$1.ForwardRefExoticComponent<HoverCardPrimitive.HoverCardTriggerProps & React$1.RefAttributes<HTMLAnchorElement>>;
+declare const HoverCardPortal: React$1.FC<HoverCardPrimitive.HoverCardPortalProps>;
+declare const HoverCardContent: React$1.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 
 interface IconProps extends React.SVGAttributes<SVGElement> {
     size?: number;
@@ -467,59 +551,137 @@ declare function AlertTriangleIcon({ size, ...props }: IconProps): react_jsx_run
 declare function ArrowRightSmallIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
 declare function ArrowLeftIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
 declare function CreditCardIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function AlertCircleIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function ArrowDownIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function ArrowUpIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function BriefcaseIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function Building2Icon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function CheckCircle2Icon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function ChevronsUpDownIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function CircleIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function CircleDotIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function CommandIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function CornerDownLeftIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function EyeOffIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function HomeIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function InboxIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function ListChecksIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function MinusIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function SlashIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function SparklesIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function Trash2Icon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function UserIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function BoldIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function ItalicIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function UnderlineIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function StrikethroughIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function ListIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function ListOrderedIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function InfoIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function HelpCircleIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function DollarSignIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function ReplyIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function KanbanIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function TableIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function HistoryIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function SaveIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+/**
+ * LoaderIcon — animated spinner. Render with `className="animate-spin"`
+ * (or `motion-safe:animate-spin` if you want to respect `prefers-reduced-
+ * motion`; the catalog doesn't gate this itself because the spinner IS
+ * the indicator for many flows).
+ *
+ * Visual contract: a dim full-circle ring + a brighter quarter-arc on top.
+ * When rotated, the bright arc creates the "leading edge" of the spinner.
+ */
+declare function LoaderIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+/**
+ * GoogleBrandIcon — Google four-color "G" mark. Brand-locked colors,
+ * does NOT respond to currentColor. Use only in provider-list UIs
+ * (OAuth buttons, integration chips). Standard 24-grid.
+ */
+declare function GoogleBrandIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+/**
+ * MicrosoftBrandIcon — Microsoft four-square mark in red / green / blue /
+ * yellow. Brand-locked colors, does NOT respond to currentColor. Use
+ * inside Microsoft OAuth signin buttons, Outlook / Office integration
+ * chips, and similar provider-list UIs. Standard 24-grid (10×10 squares
+ * with 2u gaps).
+ */
+declare function MicrosoftBrandIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+/**
+ * FilterIcon — funnel mark used for filter popover triggers across list
+ * pages (clients, workflow, billing, organizers…). Renders the same
+ * lucide-style polygon at any size; pair with a corner notification dot
+ * to surface active filter count.
+ */
+declare function FilterIcon({ size, ...props }: IconProps): react_jsx_runtime.JSX.Element;
 
-interface InputProps$1 extends React.InputHTMLAttributes<HTMLInputElement> {
+/**
+ * Input variants. Mirrors the raw HTML `<input>` styled per Assure Pro tokens
+ * (rule-strong border, surface bg, accent focus ring).
+ */
+declare const inputVariants: (props?: ({
+    variant?: "default" | "ghost" | null | undefined;
+    inputSize?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type InputVariants = VariantProps<typeof inputVariants>;
+interface InputProps$1 extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">, InputVariants {
     label?: string;
     error?: string;
     prefixIcon?: React.ReactNode;
     suffixIcon?: React.ReactNode;
 }
-declare const Input: react.ForwardRefExoticComponent<InputProps$1 & react.RefAttributes<HTMLInputElement>>;
+declare const Input: React$1.ForwardRefExoticComponent<InputProps$1 & React$1.RefAttributes<HTMLInputElement>>;
 
-declare function KeyboardShortcutsDialog(): react.ReactPortal | null;
+declare function KeyboardShortcutsDialog(): react_jsx_runtime.JSX.Element;
 
-interface LabelProps extends React.LabelHTMLAttributes<HTMLLabelElement> {
+declare const labelVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+interface LabelProps extends React$1.ComponentPropsWithoutRef<typeof LabelPrimitive.Root>, VariantProps<typeof labelVariants> {
     required?: boolean;
 }
-declare function Label({ children, required, className, ...props }: LabelProps): react_jsx_runtime.JSX.Element;
+declare const Label: React$1.ForwardRefExoticComponent<LabelProps & React$1.RefAttributes<HTMLLabelElement>>;
 
-declare const variantStyles$1: {
-    readonly primary: "bg-primary text-primary-foreground hover:bg-primary/90";
-    readonly secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80";
-    readonly destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90";
-    readonly ghost: "hover:bg-accent hover:text-accent-foreground";
-    readonly outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground";
-    readonly link: "text-primary underline-offset-4 hover:underline";
-};
-declare const sizeStyles$1: {
-    readonly sm: "h-8 px-3 text-sm gap-1.5";
-    readonly md: "h-10 px-4 text-sm gap-2";
-    readonly lg: "h-12 px-6 text-base gap-2";
-};
-interface LinkButtonProps {
+type ButtonVariant = "primary" | "secondary" | "destructive" | "success" | "ghost" | "outline" | "link" | "accent";
+type ButtonSize = "sm" | "md" | "lg";
+interface LinkButtonProps$1 extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
     href: string;
-    variant?: keyof typeof variantStyles$1;
-    size?: keyof typeof sizeStyles$1;
+    variant?: ButtonVariant;
+    size?: ButtonSize;
     iconLeft?: React.ReactNode;
     iconRight?: React.ReactNode;
     children: React.ReactNode;
     className?: string;
-    onClick?: React.MouseEventHandler<HTMLAnchorElement>;
 }
-declare function LinkButton({ href, variant, size, iconLeft, iconRight, children, className, ...props }: LinkButtonProps): react_jsx_runtime.JSX.Element;
+/**
+ * LinkButton — visually identical to `<Button>` but renders a `next/link`.
+ * Shares `buttonVariants` so styling stays in lock-step.
+ */
+declare const LinkButton: React$1.ForwardRefExoticComponent<LinkButtonProps$1 & React$1.RefAttributes<HTMLAnchorElement>>;
 
+/**
+ * Logo — Assure Pro wordmark. Per spec §4 and §6.2, the firm-app brand is
+ * "Assure Pro": "Assure" in fg + "Pro" in pro-fg purple, set in Geist
+ * (font-display). Mirrors the `.wordmark` rule in `_shared.css` (lines 226-249).
+ *
+ * Public API kept stable: `size`, `href`, `showText`, `inverted`, plus the
+ * style-override hooks (`className`, `iconClassName`, `textClassName`).
+ */
 declare const sizeStyles: {
     readonly sm: {
-        readonly icon: 24;
+        readonly icon: 20;
         readonly text: "text-sm";
+        readonly gap: "gap-2";
     };
     readonly md: {
-        readonly icon: 32;
-        readonly text: "text-lg";
+        readonly icon: 24;
+        readonly text: "text-[17px]";
+        readonly gap: "gap-2.5";
     };
     readonly lg: {
-        readonly icon: 40;
+        readonly icon: 32;
         readonly text: "text-xl";
+        readonly gap: "gap-3";
     };
 };
 interface LogoProps {
@@ -529,14 +691,14 @@ interface LogoProps {
     className?: string;
     iconClassName?: string;
     textClassName?: string;
-    /** Render wordmark for dark/brand surfaces: white "Light" + gold "Taxes". */
+    /** When true, render on dark/brand surfaces (white "Assure" + lighter "Pro"). */
     inverted?: boolean;
 }
 declare function Logo({ size, href, showText, className, iconClassName, textClassName, inverted, }: LogoProps): react_jsx_runtime.JSX.Element;
 
 interface MultiFilterPillProps {
     label: string;
-    icon?: React.ReactNode;
+    icon?: React$1.ReactNode;
     selected: Set<string>;
     options: {
         key: string;
@@ -547,6 +709,9 @@ interface MultiFilterPillProps {
     onClear: () => void;
 }
 declare function MultiFilterPill({ label, icon, selected, options, onToggle, onClear, }: MultiFilterPillProps): react_jsx_runtime.JSX.Element;
+declare namespace MultiFilterPill {
+    var displayName: string;
+}
 
 interface MultiSelectFieldProps {
     label: string;
@@ -554,8 +719,15 @@ interface MultiSelectFieldProps {
     value: string;
     onChange: (value: string) => void;
     className?: string;
+    /** Visual size; default "md" matches the form-row default. */
+    size?: "sm" | "md";
+    /** Optional id, used to associate the visible label with the group. */
+    id?: string;
+}
+declare function MultiSelectField({ label, options, value, onChange, className, size, id, }: MultiSelectFieldProps): react_jsx_runtime.JSX.Element;
+declare namespace MultiSelectField {
+    var displayName: string;
 }
-declare function MultiSelectField({ label, options, value, onChange, className, }: MultiSelectFieldProps): react_jsx_runtime.JSX.Element;
 
 interface OTPInputProps {
     name: string;
@@ -564,9 +736,31 @@ interface OTPInputProps {
     autoFocus?: boolean;
     className?: string;
     defaultValue?: string;
+    /** Optional controlled value (additive). */
+    value?: string;
+    /** Optional controlled onChange (additive). */
+    onChange?: (value: string) => void;
+    /** Optional callback fired when all slots are filled (additive). */
+    onComplete?: (value: string) => void;
+    /** Optional id for the underlying input (additive). */
+    id?: string;
+    /** Optional disabled flag (additive). */
+    disabled?: boolean;
+}
+declare function OTPInput({ name, length, error, autoFocus, className, defaultValue, value, onChange, onComplete, id, disabled, }: OTPInputProps): react_jsx_runtime.JSX.Element;
+declare namespace OTPInput {
+    var displayName: string;
 }
-declare function OTPInput({ name, length, error, autoFocus, className, defaultValue, }: OTPInputProps): react_jsx_runtime.JSX.Element;
 
+/**
+ * Pagination — custom (no Radix equivalent).
+ * Restyled to Assure Pro tokens: tabular-nums numerals, mono context label,
+ * cyan accent for the current page (matches the `.tab.is-active` treatment
+ * in `_shared.css`), `border-rule` divider boundaries.
+ *
+ * Public API preserved for 988 firm + 174 portal call sites:
+ *   currentPage, totalPages, onPageChange, siblingCount, totalItems, pageSize.
+ */
 interface PaginationProps extends React.HTMLAttributes<HTMLElement> {
     currentPage: number;
     totalPages: number;
@@ -577,7 +771,7 @@ interface PaginationProps extends React.HTMLAttributes<HTMLElement> {
     /** Items per page — used with totalItems for range display */
     pageSize?: number;
 }
-declare function Pagination({ currentPage, totalPages, onPageChange, siblingCount, totalItems, pageSize, className, ...props }: PaginationProps): react_jsx_runtime.JSX.Element | null;
+declare const Pagination: React$1.ForwardRefExoticComponent<PaginationProps & React$1.RefAttributes<HTMLElement>>;
 
 type InputProps = React.ComponentProps<typeof Input>;
 interface PhoneInputProps extends Omit<InputProps, "type" | "onChange" | "value" | "defaultValue"> {
@@ -585,41 +779,50 @@ interface PhoneInputProps extends Omit<InputProps, "type" | "onChange" | "value"
     defaultValue?: string;
     onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
 }
-declare function PhoneInput({ value, defaultValue, onChange, name, ...props }: PhoneInputProps): react_jsx_runtime.JSX.Element;
+declare const PhoneInput: React$1.ForwardRefExoticComponent<Omit<PhoneInputProps, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
 
-type Side$2 = "top" | "bottom" | "left" | "right";
-type Align = "start" | "center" | "end";
-interface PopoverProps {
-    children: React.ReactNode;
-    open?: boolean;
-    onOpenChange?: (open: boolean) => void;
-}
-declare function Popover({ children, open: controlledOpen, onOpenChange }: PopoverProps): react_jsx_runtime.JSX.Element;
-type PopoverTriggerProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
-declare function PopoverTrigger({ children, className, ...props }: PopoverTriggerProps): react_jsx_runtime.JSX.Element;
-interface PopoverContentProps extends React.HTMLAttributes<HTMLDivElement> {
-    side?: Side$2;
-    align?: Align;
-}
-declare function PopoverContent({ side, align, children, className, ...props }: PopoverContentProps): react.ReactPortal | null;
-
-declare const variantStyles: {
-    readonly default: "bg-primary";
-    readonly success: "bg-success";
-    readonly warning: "bg-warning";
-    readonly destructive: "bg-destructive";
-    readonly info: "bg-info";
-};
-interface ProgressBarProps extends React.HTMLAttributes<HTMLDivElement> {
-    value: number;
+declare const Popover: React$1.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const PopoverPortal: React$1.FC<PopoverPrimitive.PopoverPortalProps>;
+declare const PopoverClose: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * ProgressBar — Radix-driven determinate (or indeterminate) progress meter.
+ * Track sits on `bg-3`; fills follow the status palette. Variants are an
+ * explicit cva enum; if `variant` is omitted, it auto-resolves from value:
+ *   <50%  → default (Pro purple)
+ *   ≥50%  → warning
+ *   ≥80%  → success
+ *
+ * Public API preserved: `value`, `max`, `label`, `showPercentage`, `variant`.
+ * Pass `value={null}` (or omit when in-doubt) to render Radix's indeterminate
+ * state — but for back-compat we still accept `value: number`.
+ */
+declare const progressBarVariants: (props?: ({
+    variant?: "info" | "success" | "warning" | "destructive" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ProgressBarProps extends Omit<React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root>, "value">, VariantProps<typeof progressBarVariants> {
+    /** 0..max. Set to `null` for an indeterminate track. */
+    value: number | null;
     max?: number;
     label?: string;
     showPercentage?: boolean;
-    variant?: keyof typeof variantStyles;
 }
-declare function ProgressBar({ value, max, label, showPercentage, variant, className, ...props }: ProgressBarProps): react_jsx_runtime.JSX.Element;
+declare const ProgressBar: React$1.ForwardRefExoticComponent<ProgressBarProps & React$1.RefAttributes<HTMLDivElement>>;
 
-interface ProgressRingProps extends React.HTMLAttributes<HTMLDivElement> {
+/**
+ * ProgressRing — custom SVG ring meter (no Radix equivalent).
+ * Track is `bg-3`, the indicator picks up the active variant. Variants and
+ * value-driven auto-resolve mirror ProgressBar so consumers can mix freely.
+ *
+ * Public API preserved: `value`, `max`, `size`, `strokeWidth`, `label`, `sublabel`.
+ */
+declare const progressRingVariants: (props?: ({
+    variant?: "info" | "success" | "warning" | "destructive" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ProgressRingProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof progressRingVariants> {
     value: number;
     max?: number;
     size?: number;
@@ -627,33 +830,32 @@ interface ProgressRingProps extends React.HTMLAttributes<HTMLDivElement> {
     label?: string;
     sublabel?: string;
 }
-declare function ProgressRing({ value, max, size, strokeWidth, label, sublabel, className, ...props }: ProgressRingProps): react_jsx_runtime.JSX.Element;
+declare const ProgressRing: React$1.ForwardRefExoticComponent<ProgressRingProps & React$1.RefAttributes<HTMLDivElement>>;
 
-interface RadioGroupProps extends React.HTMLAttributes<HTMLDivElement> {
-    value?: string;
-    defaultValue?: string;
-    onValueChange?: (value: string) => void;
-    name?: string;
-}
-declare function RadioGroup({ value: controlledValue, defaultValue, onValueChange, name: providedName, children, className, ...props }: RadioGroupProps): react_jsx_runtime.JSX.Element;
-interface RadioGroupItemProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
-    value: string;
+declare const RadioGroup: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+interface RadioGroupItemProps extends React$1.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item> {
+    /** Optional inline label rendered to the right of the radio */
     label?: string;
 }
-declare function RadioGroupItem({ value, label, className, id: providedId, ...props }: RadioGroupItemProps): react_jsx_runtime.JSX.Element;
+declare const RadioGroupItem: React$1.ForwardRefExoticComponent<RadioGroupItemProps & React$1.RefAttributes<HTMLButtonElement>>;
 
-interface ScrollAreaProps extends React.HTMLAttributes<HTMLDivElement> {
-    children: React.ReactNode;
+interface ScrollAreaProps extends React$1.ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Root> {
+    children: React$1.ReactNode;
 }
-declare function ScrollArea({ children, className, ...props }: ScrollAreaProps): react_jsx_runtime.JSX.Element;
+declare const ScrollArea: React$1.ForwardRefExoticComponent<ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 
-interface SearchInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
+declare const searchInputVariants: (props?: ({
+    inputSize?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type SearchInputVariants = VariantProps<typeof searchInputVariants>;
+interface SearchInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "type" | "onChange" | "size">, SearchInputVariants {
     value: string;
     onValueChange: (value: string) => void;
     onSearch?: (value: string) => void;
     debounceMs?: number;
 }
-declare function SearchInput({ value, onValueChange, onSearch, debounceMs, className, placeholder, ...props }: SearchInputProps): react_jsx_runtime.JSX.Element;
+declare const SearchInput: React$1.ForwardRefExoticComponent<SearchInputProps & React$1.RefAttributes<HTMLInputElement>>;
 
 interface SearchSelectOption {
     id: string;
@@ -670,7 +872,14 @@ interface SearchSelectProps {
     disabled?: boolean;
 }
 declare function SearchSelect({ options, selected, onSelect, onRemove, onCreate, placeholder, className, disabled, }: SearchSelectProps): react_jsx_runtime.JSX.Element;
+declare namespace SearchSelect {
+    var displayName: string;
+}
 
+/**
+ * SectionHeader — title + description block for marketing-style sections.
+ * Uses Geist (`font-display`) with the spec's `-0.022em` letterspacing.
+ */
 interface SectionHeaderProps {
     title: string;
     description?: string;
@@ -679,6 +888,11 @@ interface SectionHeaderProps {
 }
 declare function SectionHeader({ title, description, align, className, }: SectionHeaderProps): react_jsx_runtime.JSX.Element;
 
+/**
+ * Section — max-width centered wrapper for marketing/section content.
+ * The `--content-pad` token (32px) is the canonical app-content gutter,
+ * but Section keeps its 24px (`px-6`) gutter for narrower marketing pages.
+ */
 declare const maxWidthStyles: {
     readonly sm: "max-w-3xl";
     readonly md: "max-w-4xl";
@@ -689,68 +903,124 @@ interface SectionProps extends React.HTMLAttributes<HTMLElement> {
     maxWidth?: keyof typeof maxWidthStyles;
     as?: "section" | "div";
 }
-declare function Section({ maxWidth, as: Tag, children, className, ...props }: SectionProps): react_jsx_runtime.JSX.Element;
-
+declare const Section: React$1.ForwardRefExoticComponent<SectionProps & React$1.RefAttributes<HTMLElement>>;
+interface SectionHeadProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title"> {
+    eyebrow?: React.ReactNode;
+    title?: React.ReactNode;
+    meta?: React.ReactNode;
+}
+declare const SectionHead: React$1.ForwardRefExoticComponent<SectionHeadProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const SelectRoot: React$1.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React$1.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * SelectOption shape — preserved verbatim from the legacy Select:
+ *   { value, label, disabled?, labelSuffix? }
+ */
 interface SelectOption {
     value: string;
     label: string;
     disabled?: boolean;
-    labelSuffix?: React.ReactNode;
+    labelSuffix?: React$1.ReactNode;
 }
 interface SelectProps {
-    children?: React.ReactNode;
+    /** Option list. Required to preserve legacy API. */
+    options: SelectOption[];
+    /** Controlled value. */
     value?: string;
+    /** Uncontrolled initial value. */
     defaultValue?: string;
     onValueChange?: (value: string) => void;
-    options: SelectOption[];
     placeholder?: string;
+    /** Accepted for back-compat. NO-OP — see file header for migration. */
     searchable?: boolean;
+    disabled?: boolean;
+    name?: string;
+    required?: boolean;
+    className?: string;
+    /** Forwarded to the trigger. */
+    triggerClassName?: string;
+    /** Forwarded to the content. */
+    contentClassName?: string;
+    /** aria-invalid + danger styling on trigger. */
+    "aria-invalid"?: boolean;
+    /** aria-label fallback when there is no visible label. */
+    "aria-label"?: string;
 }
-declare function Select({ children, value: controlledValue, defaultValue, onValueChange, options, placeholder, searchable, }: SelectProps): react_jsx_runtime.JSX.Element;
-type SelectTriggerProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
-declare function SelectTrigger({ className, ...props }: SelectTriggerProps): react_jsx_runtime.JSX.Element;
-type SelectContentProps = React.HTMLAttributes<HTMLDivElement> & {
-    position?: "bottom" | "top";
-};
-declare function SelectContent({ className, position, ...props }: SelectContentProps): react_jsx_runtime.JSX.Element | null;
-
-interface SeparatorProps extends React.HTMLAttributes<HTMLDivElement> {
-    orientation?: "horizontal" | "vertical";
-    decorative?: boolean;
+/**
+ * Convenience `Select` — preserved options-driven API.
+ *
+ * For full composition, import the lower-level slots:
+ *   <SelectRoot>
+ *     <SelectTrigger><SelectValue /></SelectTrigger>
+ *     <SelectContent>
+ *       <SelectGroup>
+ *         <SelectLabel>Label</SelectLabel>
+ *         <SelectItem value="…">…</SelectItem>
+ *       </SelectGroup>
+ *     </SelectContent>
+ *   </SelectRoot>
+ */
+declare function Select({ options, value, defaultValue, onValueChange, placeholder, searchable, disabled, name, required, className, triggerClassName, contentClassName, "aria-invalid": ariaInvalid, "aria-label": ariaLabel, }: SelectProps): react_jsx_runtime.JSX.Element;
+declare namespace Select {
+    var displayName: string;
 }
-declare function Separator({ orientation, decorative, className, ...props }: SeparatorProps): react_jsx_runtime.JSX.Element;
 
-type Side$1 = "right" | "left" | "bottom";
-interface SheetProps {
-    children: React.ReactNode;
-    open?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    side?: Side$1;
+declare const Separator: React$1.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+type Side = "top" | "right" | "bottom" | "left";
+interface SheetProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Root> {
+    /**
+     * Default side for SheetContent if it doesn't specify its own.
+     * Backwards-compat shim — prefer `<SheetContent side="…" />`.
+     */
+    side?: Side;
 }
-declare function Sheet({ children, open: controlledOpen, onOpenChange, side, }: SheetProps): react_jsx_runtime.JSX.Element;
-type SheetTriggerProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
-declare function SheetTrigger({ children, className, ...props }: SheetTriggerProps): react_jsx_runtime.JSX.Element;
-interface SheetContentProps extends React.HTMLAttributes<HTMLDivElement> {
+declare const Sheet: {
+    ({ side, children, ...props }: SheetProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SheetTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const SheetOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: ({
+    side?: "left" | "right" | "top" | "bottom" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SheetContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
+    /** If false, the built-in close button is hidden. Default: true. */
     showCloseButton?: boolean;
 }
-declare function SheetContent({ children, className, showCloseButton, ...props }: SheetContentProps): react.ReactPortal | null;
-type SheetHeaderProps = React.HTMLAttributes<HTMLDivElement>;
-declare function SheetHeader({ className, ...props }: SheetHeaderProps): react_jsx_runtime.JSX.Element;
-type SheetTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
-declare function SheetTitle({ className, ...props }: SheetTitleProps): react_jsx_runtime.JSX.Element;
-type SheetDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
-declare function SheetDescription({ className, ...props }: SheetDescriptionProps): react_jsx_runtime.JSX.Element;
-type SheetFooterProps = React.HTMLAttributes<HTMLDivElement>;
-declare function SheetFooter({ className, ...props }: SheetFooterProps): react_jsx_runtime.JSX.Element;
-type SheetCloseProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
-declare function SheetClose({ children, className, ...props }: SheetCloseProps): react_jsx_runtime.JSX.Element;
-
-interface SideDrawerProps {
+declare const SheetContent: React$1.ForwardRefExoticComponent<SheetContentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const sideDrawerVariants: (props?: ({
+    side?: "left" | "right" | null | undefined;
+    width?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SideDrawerProps extends VariantProps<typeof sideDrawerVariants> {
     open: boolean;
     onClose: () => void;
     width?: "sm" | "md" | "lg";
     side?: "right" | "left";
-    children: React.ReactNode;
+    children: React$1.ReactNode;
 }
 declare function SideDrawer({ open, onClose, width, side, children, }: SideDrawerProps): react_jsx_runtime.JSX.Element;
 declare namespace SideDrawer {
@@ -766,49 +1036,82 @@ interface SideDrawerHeaderProps {
 }
 declare function SideDrawerHeader({ title, subtitle, onClose, className }: SideDrawerHeaderProps): react_jsx_runtime.JSX.Element;
 interface SideDrawerBodyProps {
-    children: React.ReactNode;
+    children: React$1.ReactNode;
     className?: string;
 }
 declare function SideDrawerBody({ children, className }: SideDrawerBodyProps): react_jsx_runtime.JSX.Element;
 interface SideDrawerFooterProps {
-    children: React.ReactNode;
+    children: React$1.ReactNode;
     className?: string;
 }
 declare function SideDrawerFooter({ children, className }: SideDrawerFooterProps): react_jsx_runtime.JSX.Element;
 
+/**
+ * Skeleton — animated placeholder. The `.skeleton` global class supplies
+ * the shimmer animation (defined in tokens.css). All three primitives are
+ * `aria-hidden` because they're decorative loading affordances.
+ */
 interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
     className?: string;
 }
-declare function Skeleton({ className, ...props }: SkeletonProps): react_jsx_runtime.JSX.Element;
+declare const Skeleton: React$1.ForwardRefExoticComponent<SkeletonProps & React$1.RefAttributes<HTMLDivElement>>;
 interface SkeletonTextProps extends React.HTMLAttributes<HTMLDivElement> {
     lines?: number;
 }
-declare function SkeletonText({ lines, className, ...props }: SkeletonTextProps): react_jsx_runtime.JSX.Element;
+declare const SkeletonText: React$1.ForwardRefExoticComponent<SkeletonTextProps & React$1.RefAttributes<HTMLDivElement>>;
 interface SkeletonCircleProps extends React.HTMLAttributes<HTMLDivElement> {
     size?: number;
 }
-declare function SkeletonCircle({ size, className, ...props }: SkeletonCircleProps): react_jsx_runtime.JSX.Element;
+declare const SkeletonCircle: React$1.ForwardRefExoticComponent<SkeletonCircleProps & React$1.RefAttributes<HTMLDivElement>>;
 
-interface SliderProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type"> {
+interface SliderProps extends React$1.ComponentPropsWithoutRef<typeof SliderPrimitive.Root> {
+    /** Optional inline label rendered above the track */
     label?: string;
+    /** When true, renders the current value to the right of the label */
     showValue?: boolean;
 }
-declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<HTMLInputElement>>;
+declare const Slider: React$1.ForwardRefExoticComponent<SliderProps & React$1.RefAttributes<HTMLSpanElement>>;
 
-interface StarRatingProps {
+/**
+ * StarRating — display-only rating atom built on lucide `Star`. Supports
+ * fractional ratings (half-star fill via clip path) and a sized cva variant.
+ *
+ * Public API preserved: `rating`, `max`, `size`, `className`. The original
+ * accepted `size` as a number; that still works (overrides the variant). The
+ * new optional `sizeVariant` reads via cva (`sm` / `md` / `lg`).
+ */
+declare const starRatingVariants: (props?: ({
+    sizeVariant?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface StarRatingProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "role">, VariantProps<typeof starRatingVariants> {
     rating: number;
     max?: number;
+    /** Pixel size override; if set, takes precedence over `sizeVariant`. */
     size?: number;
-    className?: string;
 }
-declare function StarRating({ rating, max, size, className, }: StarRatingProps): react_jsx_runtime.JSX.Element;
+declare const StarRating: React$1.ForwardRefExoticComponent<StarRatingProps & React$1.RefAttributes<HTMLDivElement>>;
 
+/**
+ * Stat — paired numeric display + caption, the StatNum primitive from
+ * spec §4. Numerals are set in `font-display` (Geist) at a fluid clamp size
+ * with `font-variant-numeric: tabular-nums` for vertical alignment, ported
+ * from the `.stat-num` rule in `_shared.css` (lines 152-161).
+ */
 interface StatProps extends React.HTMLAttributes<HTMLDivElement> {
     value: string;
     label: string;
 }
-declare function Stat({ value, label, className, ...props }: StatProps): react_jsx_runtime.JSX.Element;
+declare const Stat: React$1.ForwardRefExoticComponent<StatProps & React$1.RefAttributes<HTMLDivElement>>;
 
+/**
+ * Stepper — custom progress indicator. No Radix equivalent.
+ * Active step uses Pro purple; completed steps use the success palette;
+ * connector lines pick up the same status. Supports horizontal (default)
+ * and vertical orientation.
+ *
+ * Public API preserved: `steps`, `currentStep`, plus the new optional
+ * `orientation` prop for vertical layouts.
+ */
 interface Step {
     label: string;
     description?: string;
@@ -816,70 +1119,68 @@ interface Step {
 interface StepperProps extends React.HTMLAttributes<HTMLDivElement> {
     steps: Step[];
     currentStep: number;
+    orientation?: "horizontal" | "vertical";
 }
-declare function Stepper({ steps, currentStep, className, ...props }: StepperProps): react_jsx_runtime.JSX.Element;
+declare const Stepper: React$1.ForwardRefExoticComponent<StepperProps & React$1.RefAttributes<HTMLDivElement>>;
 
-interface SubmitButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "type"> {
+interface SubmitButtonProps extends Omit<ButtonProps, "type" | "loading"> {
     pendingText?: string;
     children: React.ReactNode;
 }
-declare function SubmitButton({ pendingText, children, className, ...props }: SubmitButtonProps): react_jsx_runtime.JSX.Element;
+/**
+ * SubmitButton — react-dom `useFormStatus`-aware Button.
+ * Auto-disables and shows `pendingText` (or spinner) while the form is pending.
+ */
+declare const SubmitButton: React$1.ForwardRefExoticComponent<SubmitButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
 
-declare const sizeConfig: {
-    readonly sm: {
-        readonly track: "h-5 w-9";
-        readonly thumb: "size-3.5";
-        readonly translate: "translate-x-4";
-    };
-    readonly md: {
-        readonly track: "h-6 w-11";
-        readonly thumb: "size-4.5";
-        readonly translate: "translate-x-5";
-    };
-};
-interface SwitchProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onChange"> {
-    checked?: boolean;
-    defaultChecked?: boolean;
-    onCheckedChange?: (checked: boolean) => void;
+declare const switchVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SwitchProps extends Omit<React$1.ComponentPropsWithoutRef<typeof SwitchPrimitive.Root>, "size">, VariantProps<typeof switchVariants> {
     label?: string;
-    size?: keyof typeof sizeConfig;
 }
-declare function Switch({ checked: controlledChecked, defaultChecked, onCheckedChange, label, size, className, id: providedId, ...props }: SwitchProps): react_jsx_runtime.JSX.Element;
+declare const Switch: React$1.ForwardRefExoticComponent<SwitchProps & React$1.RefAttributes<HTMLButtonElement>>;
 
+/**
+ * Table — semantic data-table primitives. Ports the `.data-table` rules
+ * from `_shared.css` (lines 542-590):
+ *   - mono uppercase headers (10px, 0.12em tracking) on `bg-surface-2`
+ *   - 1px `border-rule` under header, `border-rule-soft` between rows
+ *   - 13px body cells in `text-fg-2`, hover row gets `bg-bg-2`
+ *
+ * Public API preserved: Table / TableHeader / TableBody / TableRow /
+ * TableHead / TableCell / TableCaption. `wrapperClassName` still wraps
+ * the responsive overflow container.
+ */
 interface TableProps extends React.TableHTMLAttributes<HTMLTableElement> {
+    /** Class for the wrapping `div` that handles overflow. */
     wrapperClassName?: string;
 }
-declare function Table({ className, wrapperClassName, ...props }: TableProps): react_jsx_runtime.JSX.Element;
+declare const Table: React$1.ForwardRefExoticComponent<TableProps & React$1.RefAttributes<HTMLTableElement>>;
 type TableHeaderProps = React.HTMLAttributes<HTMLTableSectionElement>;
-declare function TableHeader({ className, ...props }: TableHeaderProps): react_jsx_runtime.JSX.Element;
+declare const TableHeader: React$1.ForwardRefExoticComponent<TableHeaderProps & React$1.RefAttributes<HTMLTableSectionElement>>;
 type TableBodyProps = React.HTMLAttributes<HTMLTableSectionElement>;
-declare function TableBody({ className, ...props }: TableBodyProps): react_jsx_runtime.JSX.Element;
+declare const TableBody: React$1.ForwardRefExoticComponent<TableBodyProps & React$1.RefAttributes<HTMLTableSectionElement>>;
+type TableFooterProps = React.HTMLAttributes<HTMLTableSectionElement>;
+declare const TableFooter: React$1.ForwardRefExoticComponent<TableFooterProps & React$1.RefAttributes<HTMLTableSectionElement>>;
 type TableRowProps = React.HTMLAttributes<HTMLTableRowElement>;
-declare function TableRow({ className, ...props }: TableRowProps): react_jsx_runtime.JSX.Element;
+declare const TableRow: React$1.ForwardRefExoticComponent<TableRowProps & React$1.RefAttributes<HTMLTableRowElement>>;
 type TableHeadProps = React.ThHTMLAttributes<HTMLTableCellElement>;
-declare function TableHead({ className, ...props }: TableHeadProps): react_jsx_runtime.JSX.Element;
+declare const TableHead: React$1.ForwardRefExoticComponent<TableHeadProps & React$1.RefAttributes<HTMLTableCellElement>>;
 type TableCellProps = React.TdHTMLAttributes<HTMLTableCellElement>;
-declare function TableCell({ className, ...props }: TableCellProps): react_jsx_runtime.JSX.Element;
+declare const TableCell: React$1.ForwardRefExoticComponent<TableCellProps & React$1.RefAttributes<HTMLTableCellElement>>;
 type TableCaptionProps = React.HTMLAttributes<HTMLTableCaptionElement>;
-declare function TableCaption({ className, ...props }: TableCaptionProps): react_jsx_runtime.JSX.Element;
+declare const TableCaption: React$1.ForwardRefExoticComponent<TableCaptionProps & React$1.RefAttributes<HTMLTableCaptionElement>>;
 
-interface TabsProps extends React.HTMLAttributes<HTMLDivElement> {
-    value?: string;
-    defaultValue?: string;
-    onValueChange?: (value: string) => void;
-}
-declare function Tabs({ value: controlledValue, defaultValue, onValueChange, children, className, ...props }: TabsProps): react_jsx_runtime.JSX.Element;
-type TabsListProps = React.HTMLAttributes<HTMLDivElement>;
-declare function TabsList({ children, className, ...props }: TabsListProps): react_jsx_runtime.JSX.Element;
-interface TabsTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
-    value: string;
-    variant?: "pill" | "underline";
+declare const Tabs: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const triggerVariants: (props?: ({
+    variant?: "underline" | "pill" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TabsTriggerProps extends React$1.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger>, VariantProps<typeof triggerVariants> {
 }
-declare function TabsTrigger({ value, variant, children, className, ...props }: TabsTriggerProps): react_jsx_runtime.JSX.Element;
-interface TabsContentProps extends React.HTMLAttributes<HTMLDivElement> {
-    value: string;
-}
-declare function TabsContent({ value, children, className, ...props }: TabsContentProps): react_jsx_runtime.JSX.Element | null;
+declare const TabsTrigger: React$1.ForwardRefExoticComponent<TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 
 interface TeamMember {
     id: string;
@@ -892,16 +1193,25 @@ interface TeamMemberSelectProps {
     onValueChange: (value: string) => void;
     includeUnassigned?: boolean;
     placeholder?: string;
+    className?: string;
+}
+declare function TeamMemberSelect({ teamMembers, currentUserId, value, onValueChange, includeUnassigned, placeholder, className, }: TeamMemberSelectProps): react_jsx_runtime.JSX.Element;
+declare namespace TeamMemberSelect {
+    var displayName: string;
 }
-declare function TeamMemberSelect({ teamMembers, currentUserId, value, onValueChange, includeUnassigned, placeholder, }: TeamMemberSelectProps): react_jsx_runtime.JSX.Element;
 
-interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+declare const textareaVariants: (props?: ({
+    variant?: "default" | "ghost" | null | undefined;
+    inputSize?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type TextareaVariants = VariantProps<typeof textareaVariants>;
+interface TextareaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "size">, TextareaVariants {
     label?: string;
     error?: string;
     showCount?: boolean;
     autoResize?: boolean;
 }
-declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
+declare const Textarea: React$1.ForwardRefExoticComponent<TextareaProps & React$1.RefAttributes<HTMLTextAreaElement>>;
 
 type ToastVariant = "default" | "success" | "destructive" | "warning";
 interface Toast {
@@ -912,7 +1222,8 @@ interface Toast {
     duration?: number;
 }
 interface ToastContextValue {
-    toast: (options: Omit<Toast, "id">) => void;
+    toast: (options: Omit<Toast, "id">) => string;
+    dismiss: (id?: string) => void;
 }
 declare function useToast(): ToastContextValue;
 interface ToastProviderProps {
@@ -920,37 +1231,562 @@ interface ToastProviderProps {
 }
 declare function ToastProvider({ children }: ToastProviderProps): react_jsx_runtime.JSX.Element;
 
-interface ToggleGroupProps extends React.HTMLAttributes<HTMLDivElement> {
-    type?: "single" | "multiple";
-    value?: string[];
-    defaultValue?: string[];
-    onValueChange?: (value: string[]) => void;
-    variant?: "default" | "outline";
+declare const itemVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ToggleGroupRootProps = React$1.ComponentPropsWithoutRef<typeof ToggleGroupPrimitive.Root> & VariantProps<typeof itemVariants>;
+declare const ToggleGroup: React$1.ForwardRefExoticComponent<ToggleGroupRootProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ToggleGroupItemProps extends React$1.ComponentPropsWithoutRef<typeof ToggleGroupPrimitive.Item>, VariantProps<typeof itemVariants> {
+}
+declare const ToggleGroupItem: React$1.ForwardRefExoticComponent<ToggleGroupItemProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const TooltipProvider: React$1.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const TooltipTrigger: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TooltipPortal: React$1.FC<TooltipPrimitive.TooltipPortalProps>;
+interface TooltipProps extends React$1.ComponentPropsWithoutRef<typeof TooltipPrimitive.Root> {
+    /**
+     * Backwards-compat alias for Radix's `delayDuration`. Kept so existing
+     * call sites that passed `delayMs={…}` keep working unchanged.
+     */
+    delayMs?: number;
+    /**
+     * Optional delayDuration applied to the implicit Provider. Forwarded
+     * here when no surrounding `<TooltipProvider>` is present.
+     */
+    delayDuration?: number;
+}
+declare const Tooltip: {
+    ({ delayMs, delayDuration, children, ...props }: TooltipProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const TooltipContent: React$1.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * VisuallyHidden — hides content from sighted users while keeping it
+ * available to assistive tech. Backed by `@radix-ui/react-visually-hidden`
+ * (the canonical implementation; survives strict-mode + portals).
+ */
+interface VisuallyHiddenProps extends React.ComponentPropsWithoutRef<typeof VisuallyHiddenPrimitive.Root> {
+    children: React.ReactNode;
 }
-declare function ToggleGroup({ type, value: controlledValue, defaultValue, onValueChange, variant, children, className, ...props }: ToggleGroupProps): react_jsx_runtime.JSX.Element;
-interface ToggleGroupItemProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
-    value: string;
+declare const VisuallyHidden: React$1.ForwardRefExoticComponent<VisuallyHiddenProps & React$1.RefAttributes<HTMLSpanElement>>;
+
+type ShellProps = React.HTMLAttributes<HTMLDivElement>;
+declare const Shell: React$1.ForwardRefExoticComponent<ShellProps & React$1.RefAttributes<HTMLDivElement>>;
+type MainProps = React.HTMLAttributes<HTMLElement>;
+declare const Main: React$1.ForwardRefExoticComponent<MainProps & React$1.RefAttributes<HTMLElement>>;
+interface ContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Override the bottom padding only — the rest of the content area keeps
+     * `--content-pad` so the header alignment stays intact. Use this on
+     * long-scroll pages (Kanban, document trees, large tables) that want
+     * extra breathing room beneath the last row.
+     *
+     * Accepts any CSS length (e.g. `"64px"`, `"4rem"`). Omit to inherit
+     * the symmetric default.
+     */
+    padBottom?: string;
+}
+declare const Content: React$1.ForwardRefExoticComponent<ContentProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type SidebarState = "expanded" | "rail";
+interface SidebarContextValue {
+    state: SidebarState;
+    setState: (next: SidebarState) => void;
+    toggle: () => void;
+    collapsible: boolean;
+}
+declare function useSidebarState(): SidebarContextValue;
+interface SidebarProviderProps {
+    children?: React$1.ReactNode;
+    state?: SidebarState;
+    defaultState?: SidebarState;
+    onStateChange?: (next: SidebarState) => void;
+    /** Persist the user's intent across reloads under this localStorage key. */
+    storageKey?: string;
+    /** Global toggle shortcut. Pass `null` to disable. Defaults to `Mod+\`. */
+    shortcut?: string | null;
+}
+declare function SidebarProvider({ children, state: controlled, defaultState, onStateChange, storageKey, shortcut, }: SidebarProviderProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarProvider {
+    var displayName: string;
+}
+interface SidebarProps extends React$1.HTMLAttributes<HTMLElement> {
+    /**
+     * Opt into the rail / hover-peek behavior. When false (default), the
+     * sidebar always renders expanded — the legacy behavior. When true,
+     * the sidebar reads pinned state from <SidebarProvider>; if no
+     * provider is mounted it still renders expanded, so dropping
+     * `collapsible` alone is a no-op.
+     */
+    collapsible?: boolean;
+}
+declare const Sidebar: React$1.ForwardRefExoticComponent<SidebarProps & React$1.RefAttributes<HTMLElement>>;
+interface SidebarTriggerProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    expandLabel?: string;
+    collapseLabel?: string;
+}
+declare const SidebarTrigger: React$1.ForwardRefExoticComponent<SidebarTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+type SidebarBrandProps = React$1.HTMLAttributes<HTMLDivElement>;
+declare const SidebarBrand: React$1.ForwardRefExoticComponent<SidebarBrandProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * Text portion of the brand row. Hides itself when the sidebar
+ * collapses to a rail. Use to wrap product names / wordmarks so the
+ * logo glyph alone remains visible at 64px.
+ */
+type SidebarBrandTextProps = React$1.HTMLAttributes<HTMLSpanElement>;
+declare const SidebarBrandText: React$1.ForwardRefExoticComponent<SidebarBrandTextProps & React$1.RefAttributes<HTMLSpanElement>>;
+interface SidebarSectionProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    label?: React$1.ReactNode;
+    /**
+     * Label color tone. Encodes the *meaning* of the section's
+     * priority in the scan path:
+     *   - `"pro"` (default) — Pro-purple, for primary day-to-day work.
+     *   - `"muted"` — `text-fg-3`, for system-level or settings groups
+     *     that should sit lower in the visual hierarchy.
+     *
+     * Mirrors the `tone` API on `<SidebarLinkBadge>`.
+     */
+    tone?: "pro" | "muted";
+}
+declare const SidebarSection: React$1.ForwardRefExoticComponent<SidebarSectionProps & React$1.RefAttributes<HTMLDivElement>>;
+interface SidebarLinkProps extends React$1.AnchorHTMLAttributes<HTMLAnchorElement> {
+    /** Required when rendered as `<a>`; ignored when `asChild` is true. */
+    href?: string;
+    icon?: React$1.ReactNode;
+    active?: boolean;
+    /**
+     * Render via Radix `<Slot>` so the consumer can wrap a router-aware
+     * component (e.g. Next.js `<Link>`, React Router `<NavLink>`) that
+     * owns `href` and prefetch behavior. Without this, sidebar clicks
+     * bypass client-side routing and trigger full page loads.
+     */
+    asChild?: boolean;
+}
+declare const SidebarLink: React$1.ForwardRefExoticComponent<SidebarLinkProps & React$1.RefAttributes<HTMLAnchorElement>>;
+/**
+ * Label slot for `<SidebarLink asChild>` consumers.
+ *
+ * The default (non-`asChild`) `SidebarLink` already hides its label in rail
+ * mode. When consumers opt into `asChild` to wrap a router-aware element,
+ * the design system can't reach inside to apply that rule — so consumers
+ * compose this atom around their label text. Removes the leaky requirement
+ * that every consumer re-stamp `group-data-[labels=hide]/sidebar:hidden`
+ * on their inner spans.
+ */
+type SidebarLinkLabelProps = React$1.HTMLAttributes<HTMLSpanElement>;
+declare const SidebarLinkLabel: React$1.ForwardRefExoticComponent<SidebarLinkLabelProps & React$1.RefAttributes<HTMLSpanElement>>;
+/**
+ * Optional trailing action inside a `<SidebarLink asChild>` (e.g. an
+ * expand/collapse chevron for a nested section). Hides in rail because the
+ * action is not meaningful when labels themselves are hidden.
+ */
+type SidebarLinkActionProps = React$1.HTMLAttributes<HTMLSpanElement>;
+declare const SidebarLinkAction: React$1.ForwardRefExoticComponent<SidebarLinkActionProps & React$1.RefAttributes<HTMLSpanElement>>;
+declare const sidebarLinkBadgeVariants: (props?: ({
+    tone?: "warning" | "default" | "neutral" | "danger" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type SidebarLinkBadgeVariants = VariantProps<typeof sidebarLinkBadgeVariants>;
+interface SidebarLinkBadgeProps extends React$1.HTMLAttributes<HTMLSpanElement>, SidebarLinkBadgeVariants {
+}
+declare const SidebarLinkBadge: React$1.ForwardRefExoticComponent<SidebarLinkBadgeProps & React$1.RefAttributes<HTMLSpanElement>>;
+interface SidebarLinkGroupProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onClick"> {
+    /**
+     * Stable id used for exclusive-mode coordination. Defaults to a
+     * generated React id, which is stable across renders within a
+     * single tree.
+     */
+    id?: string;
+    icon?: React$1.ReactNode;
+    label: React$1.ReactNode;
+    /** Body href — the body row renders as `<a href>`. */
+    href?: string;
+    /** Highlights the body row. Independent of the open state. */
+    active?: boolean;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Called when the body row is clicked, before the open state is
+     * updated and before the section's exclusive lock is claimed. Call
+     * `e.preventDefault()` to opt out of both. Use for navigation that
+     * needs to run *before* the accordion behavior (rare).
+     */
+    onActivate?: (e: React$1.MouseEvent<HTMLAnchorElement>) => void;
+    children?: React$1.ReactNode;
+}
+declare const SidebarLinkGroup: React$1.ForwardRefExoticComponent<SidebarLinkGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+type SidebarFooterProps = React$1.HTMLAttributes<HTMLDivElement>;
+declare const SidebarFooter: React$1.ForwardRefExoticComponent<SidebarFooterProps & React$1.RefAttributes<HTMLDivElement>>;
+interface SidebarUserProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    name: string;
+    subtitle?: React$1.ReactNode;
+    avatarSrc?: string | null;
 }
-declare function ToggleGroupItem({ value, children, className, ...props }: ToggleGroupItemProps): react_jsx_runtime.JSX.Element;
+declare const SidebarUser: React$1.ForwardRefExoticComponent<SidebarUserProps & React$1.RefAttributes<HTMLDivElement>>;
 
-type Side = "top" | "right" | "bottom" | "left";
-interface TooltipProps {
-    children: React.ReactNode;
-    delayMs?: number;
+/**
+ * AppHeader — sticky 56px-tall top bar mounted inside `<Main>`, above
+ * `<Content>`. Ports `.app-header` from `_shared.css` (lines 393-404).
+ *
+ * Children flow horizontally:
+ *   breadcrumb → title → flex-1 spacer → search → actions
+ *
+ * Sub-components are layout slots; the consumer composes them in any order
+ * and the AppHeaderSearch's `flex-1` collapses any remaining space.
+ */
+type AppHeaderProps = React.HTMLAttributes<HTMLElement>;
+declare const AppHeader: React$1.ForwardRefExoticComponent<AppHeaderProps & React$1.RefAttributes<HTMLElement>>;
+type AppHeaderBreadcrumbProps = React.HTMLAttributes<HTMLElement>;
+declare const AppHeaderBreadcrumb: React$1.ForwardRefExoticComponent<AppHeaderBreadcrumbProps & React$1.RefAttributes<HTMLElement>>;
+type AppHeaderTitleProps = React.HTMLAttributes<HTMLSpanElement>;
+/**
+ * App-shell title rendered inside the sticky header.
+ *
+ * Intentionally a `<span>` rather than `<h1>`: the page below the chrome
+ * owns its own document heading (`<h1>` in the page body). The header is
+ * navigational chrome; making it the page's `<h1>` would couple every page
+ * heading to the chrome wrapper and confuse screen-reader heading nav.
+ */
+declare const AppHeaderTitle: React$1.ForwardRefExoticComponent<AppHeaderTitleProps & React$1.RefAttributes<HTMLSpanElement>>;
+interface AppHeaderSearchProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Placeholder text rendered inside the search trigger. */
+    placeholder?: string;
+    /** Keyboard shortcut hint shown on the right. Defaults to ⌘K. */
+    shortcut?: React.ReactNode;
 }
-declare function Tooltip({ children, delayMs }: TooltipProps): react_jsx_runtime.JSX.Element;
-type TooltipTriggerProps = React.HTMLAttributes<HTMLSpanElement>;
-declare function TooltipTrigger({ children, className, ...props }: TooltipTriggerProps): react_jsx_runtime.JSX.Element;
-interface TooltipContentProps extends React.HTMLAttributes<HTMLDivElement> {
-    side?: Side;
+declare const AppHeaderSearch: React$1.ForwardRefExoticComponent<AppHeaderSearchProps & React$1.RefAttributes<HTMLButtonElement>>;
+type AppHeaderActionsProps = React.HTMLAttributes<HTMLDivElement>;
+declare const AppHeaderActions: React$1.ForwardRefExoticComponent<AppHeaderActionsProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * PageHeader — top-of-page title block: eyebrow → headline → meta row.
+ * Ports `.page-header` rules from `_shared.css` (lines 486-498).
+ *
+ * `title` is a string per the consumer-side contract (see
+ * `assure-pro-spec/from-lighttaxes-claude.md`, "Page header" section).
+ * If a consumer needs richer markup in the headline they should compose
+ * around PageHeader rather than via this prop.
+ */
+interface PageHeaderProps extends Omit<React.HTMLAttributes<HTMLElement>, "title"> {
+    /** Slot above the title — usually `<Eyebrow numeric>`. */
+    eyebrow?: React.ReactNode;
+    /** Page title text. */
+    title: string;
+    /** Slot below the title for pills, specs, separators. */
+    meta?: React.ReactNode;
 }
-declare function TooltipContent({ side, children, className, ...props }: TooltipContentProps): react.ReactPortal | null;
+declare const PageHeader: React$1.ForwardRefExoticComponent<PageHeaderProps & React$1.RefAttributes<HTMLElement>>;
+type PageHeaderSpecProps = React.HTMLAttributes<HTMLSpanElement>;
+/**
+ * PageHeaderSpec — small `.spec`-style span (Geist Mono w/ tnum/lnum/ss01).
+ * Used inside the `meta` slot for numeric facts ("4 due today",
+ * "EIN ·· 12-3456789").
+ */
+declare const PageHeaderSpec: React$1.ForwardRefExoticComponent<PageHeaderSpecProps & React$1.RefAttributes<HTMLSpanElement>>;
+type PageHeaderSepProps = React.HTMLAttributes<HTMLSpanElement>;
+/** PageHeaderSep — the `·` dot separator used between meta items. */
+declare const PageHeaderSep: React$1.ForwardRefExoticComponent<PageHeaderSepProps & React$1.RefAttributes<HTMLSpanElement>>;
 
-interface VisuallyHiddenProps extends React.HTMLAttributes<HTMLSpanElement> {
-    children: React.ReactNode;
+interface DataTableProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** When true, renders the table card with a flat top edge so it
+     *  visually attaches to a `<DataTableToolbar>` above it. */
+    withToolbar?: boolean;
+}
+/**
+ * DataTable — outer wrapper. Children are typically:
+ *   <DataTableToolbar /> + <table> + <DataTablePagination />.
+ *
+ * The `<table>` is hand-written by the consumer; this wrapper renders
+ * the surface card chrome on its descendant `<table>` element via a
+ * Tailwind arbitrary-variant selector. When `withToolbar` is set, the
+ * top corners flatten so the table visually joins the toolbar above.
+ *
+ * Children render in document order — toolbar (if any) then `<table>`
+ * then pagination — with the table card and the pagination not sharing
+ * a background.
+ */
+declare const DataTable: React$1.ForwardRefExoticComponent<DataTableProps & React$1.RefAttributes<HTMLDivElement>>;
+type DataTableToolbarProps = React.HTMLAttributes<HTMLDivElement>;
+/**
+ * DataTableToolbar — top row above the table. Renders the same surface
+ * card as `<table>`, but with rounded corners only on top so the table
+ * below visually attaches to it (see `.toolbar` rules in `_shared.css`,
+ * lines 592-633).
+ */
+declare const DataTableToolbar: React$1.ForwardRefExoticComponent<DataTableToolbarProps & React$1.RefAttributes<HTMLDivElement>>;
+interface DataTableSearchProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size"> {
+    /** Override the default placeholder. */
+    placeholder?: string;
+}
+/**
+ * DataTableSearch — small search input slot inside the toolbar. Wraps
+ * the `Input` primitive at `inputSize="sm"` with a leading search icon.
+ */
+declare const DataTableSearch: React$1.ForwardRefExoticComponent<DataTableSearchProps & React$1.RefAttributes<HTMLInputElement>>;
+type DataTableSpacerProps = React.HTMLAttributes<HTMLSpanElement>;
+/** DataTableSpacer — `flex-1` spacer for arranging toolbar items. */
+declare const DataTableSpacer: React$1.ForwardRefExoticComponent<DataTableSpacerProps & React$1.RefAttributes<HTMLSpanElement>>;
+interface DataTableResultsCountProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> {
+    current: number;
+    total: number;
+}
+/**
+ * DataTableResultsCount — small spec-styled "12 of 247" indicator.
+ * Mono + tabular per `.results-count` (`_shared.css` lines 628-633).
+ */
+declare const DataTableResultsCount: React$1.ForwardRefExoticComponent<DataTableResultsCountProps & React$1.RefAttributes<HTMLSpanElement>>;
+/**
+ * DataTableHead — wraps `<thead>`. Renders the surface-2 header row
+ * with the rule-bottom divider (`.data-table th` styling lives on the
+ * `DataTableHeader` cells themselves).
+ */
+type DataTableHeadProps = React.HTMLAttributes<HTMLTableSectionElement>;
+declare const DataTableHead: React$1.ForwardRefExoticComponent<DataTableHeadProps & React$1.RefAttributes<HTMLTableSectionElement>>;
+type DataTableBodyProps = React.HTMLAttributes<HTMLTableSectionElement>;
+/** DataTableBody — wraps `<tbody>`. Last row drops its bottom border. */
+declare const DataTableBody: React$1.ForwardRefExoticComponent<DataTableBodyProps & React$1.RefAttributes<HTMLTableSectionElement>>;
+interface DataTableRowProps extends React.HTMLAttributes<HTMLTableRowElement> {
+    /** Pro-tinted highlight for the current selection. */
+    selected?: boolean;
+}
+/**
+ * DataTableRow — `<tr>` with hover styling. `selected` switches the
+ * row to the Pro-bg highlight (matches `data-[state=selected]` on the
+ * Table primitive).
+ */
+declare const DataTableRow: React$1.ForwardRefExoticComponent<DataTableRowProps & React$1.RefAttributes<HTMLTableRowElement>>;
+type SortDirection = "asc" | "desc";
+interface DataTableHeaderProps extends React.ThHTMLAttributes<HTMLTableCellElement> {
+    /** When true, the cell becomes a clickable button that toggles sort
+     *  state and renders a chevron indicator. */
+    sortable?: boolean;
+    /** Initial sort direction when the header mounts in a sorted state. */
+    defaultSort?: SortDirection;
+    /** Optional controlled sort state. When provided, `onSortChange` should
+     *  also be wired up — the header becomes fully controlled. */
+    sort?: SortDirection | null;
+    /** Fires whenever the user clicks a sortable header. */
+    onSortChange?: (sort: SortDirection | null) => void;
+}
+/**
+ * DataTableHeader — `<th>` cell. Mono uppercase label with optional
+ * sort indicator. Sort cycle when uncontrolled:
+ *   unsorted → asc → desc → unsorted (3-state).
+ * `defaultSort` seeds the initial state. Pass `sort` + `onSortChange`
+ * for fully-controlled usage when an upstream store owns the sort.
+ */
+declare const DataTableHeader: React$1.ForwardRefExoticComponent<DataTableHeaderProps & React$1.RefAttributes<HTMLTableCellElement>>;
+type DataTableCellProps = React.TdHTMLAttributes<HTMLTableCellElement>;
+/** DataTableCell — default cell, 13px / fg-2. */
+declare const DataTableCell: React$1.ForwardRefExoticComponent<DataTableCellProps & React$1.RefAttributes<HTMLTableCellElement>>;
+/**
+ * DataTableCellName — primary identifier of the row. Display font,
+ * fg color, medium weight (matches `.cell-name` in `_shared.css`
+ * line 586).
+ */
+declare const DataTableCellName: React$1.ForwardRefExoticComponent<DataTableCellProps & React$1.RefAttributes<HTMLTableCellElement>>;
+/**
+ * DataTableCellMono — currency / IDs / numerics. Geist Mono with
+ * tabular numerals and the same tight tracking the spec uses
+ * (`.cell-mono`, `_shared.css` lines 579-584).
+ */
+declare const DataTableCellMono: React$1.ForwardRefExoticComponent<DataTableCellProps & React$1.RefAttributes<HTMLTableCellElement>>;
+/**
+ * DataTableCellId — muted mono ID (EIN, UUID, "5h ago"). Matches
+ * `.cell-mono.cell-id` from the spec.
+ */
+declare const DataTableCellId: React$1.ForwardRefExoticComponent<DataTableCellProps & React$1.RefAttributes<HTMLTableCellElement>>;
+interface DataTableCellDueProps extends Omit<React.TdHTMLAttributes<HTMLTableCellElement>, "children"> {
+    /** Date this row is due. */
+    value: Date;
+    /** Optional override for the displayed label (defaults to the
+     *  formatted date). */
+    children?: ReactNode;
+}
+/**
+ * DataTableCellDue — accepts a Date and auto-colors:
+ *   diff < 0      → text-danger-fg  (overdue)
+ *   diff < 14d    → text-warning-fg (due-near)
+ *   otherwise     → text-fg-3       (default)
+ *
+ * The 14-day threshold and day-rounding (`Math.floor`) match the
+ * `.cell-due-near` / `.cell-due-overdue` CSS classes in the mockup.
+ */
+declare const DataTableCellDue: React$1.ForwardRefExoticComponent<DataTableCellDueProps & React$1.RefAttributes<HTMLTableCellElement>>;
+interface DataTableCheckboxProps extends Omit<React.TdHTMLAttributes<HTMLTableCellElement>, "onChange" | "defaultChecked"> {
+    /** Forwarded to the inner `Checkbox` primitive. */
+    checked?: boolean | "indeterminate";
+    defaultChecked?: boolean | "indeterminate";
+    onCheckedChange?: (checked: boolean | "indeterminate") => void;
+    /** Accessible label for the checkbox (e.g. "Select row Acme Corp."). */
+    ariaLabel?: string;
+    disabled?: boolean;
+    /** Render the cell as `<th>` (for the select-all header) instead of `<td>`. */
+    asHeader?: boolean;
+}
+/**
+ * DataTableCheckbox — `<td>` containing the row-selection checkbox.
+ * Tightened to a 32px column with no right padding to match
+ * `.row-checkbox` in the spec.
+ */
+declare const DataTableCheckbox: React$1.ForwardRefExoticComponent<DataTableCheckboxProps & React$1.RefAttributes<HTMLTableCellElement>>;
+interface DataTablePaginationProps extends Omit<React.HTMLAttributes<HTMLElement>, "onChange"> {
+    /** 1-indexed current page. */
+    current: number;
+    /** Total number of items across all pages. */
+    total: number;
+    /** Items per page. Default 25. */
+    pageSize?: number;
+    onPageChange?: (page: number) => void;
+    siblingCount?: number;
+}
+/**
+ * DataTablePagination — full pagination strip. Wraps the existing
+ * `Pagination` primitive: derives `pageCount` from `total / pageSize`
+ * and forwards the page label ("1–25 of 327"). Page size defaults to
+ * 25 (the consumer contract did not specify; this matches the most
+ * common firm-app table page size).
+ */
+declare const DataTablePagination: React$1.ForwardRefExoticComponent<DataTablePaginationProps & React$1.RefAttributes<HTMLElement>>;
+
+/**
+ * Detail layout composites — port of the `.detail-grid` / `.detail-spine`
+ * pattern from `_shared.css` (lines 814-822) and the canonical detail page
+ * mockup (`assure-pro-spec/mockups/04-client-detail.html`).
+ *
+ * Two-column layout: a sticky left rail (the "spine", 320px) holding
+ * identity + key facts, and a scrollable main column for tabs, sections,
+ * tables, and activity feeds.
+ */
+type DetailGridProps = React.HTMLAttributes<HTMLDivElement>;
+declare const DetailGrid: React$1.ForwardRefExoticComponent<DetailGridProps & React$1.RefAttributes<HTMLDivElement>>;
+type DetailSpineProps = React.HTMLAttributes<HTMLElement>;
+declare const DetailSpine: React$1.ForwardRefExoticComponent<DetailSpineProps & React$1.RefAttributes<HTMLElement>>;
+interface DetailSpineHeaderProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title"> {
+    /** Image src or initials/name string passed through to <Avatar>. */
+    avatar: string;
+    /** Display name / entity title. */
+    title: string;
+    /** Smaller line under the title — entity type, classification, etc. */
+    subtitle: string;
+}
+declare const DetailSpineHeader: React$1.ForwardRefExoticComponent<DetailSpineHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+interface DetailSpineSectionProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Small caps label rendered above the section content. */
+    eyebrow: string;
 }
-declare function VisuallyHidden({ children, className, ...props }: VisuallyHiddenProps): react_jsx_runtime.JSX.Element;
+declare const DetailSpineSection: React$1.ForwardRefExoticComponent<DetailSpineSectionProps & React$1.RefAttributes<HTMLDivElement>>;
+type DetailSpineStatsProps = React.HTMLAttributes<HTMLDivElement>;
+declare const DetailSpineStats: React$1.ForwardRefExoticComponent<DetailSpineStatsProps & React$1.RefAttributes<HTMLDivElement>>;
+type DetailMainProps = React.HTMLAttributes<HTMLElement>;
+declare const DetailMain: React$1.ForwardRefExoticComponent<DetailMainProps & React$1.RefAttributes<HTMLElement>>;
+
+/**
+ * ActivityList — vertical feed of activity rows.
+ * Ports `.activity-list` / `.activity-item` from `_shared.css` (lines 635-664)
+ * with the simplified row API from `from-lighttaxes-claude.md` (line 71):
+ *
+ *   <ActivityList>
+ *     <ActivityItem dot="success" actor="Anna" text="filed" target="1120S" time="2h ago" />
+ *   </ActivityList>
+ */
+type ActivityListProps = React.HTMLAttributes<HTMLUListElement>;
+declare const ActivityList: React$1.ForwardRefExoticComponent<ActivityListProps & React$1.RefAttributes<HTMLUListElement>>;
+type ActivityDotVariant = "default" | "success" | "warn" | "accent";
+interface ActivityItemProps extends Omit<React.LiHTMLAttributes<HTMLLIElement>, "children"> {
+    dot?: ActivityDotVariant;
+    actor: string;
+    text: string;
+    target?: string;
+    time: string;
+}
+declare const ActivityItem: React$1.ForwardRefExoticComponent<ActivityItemProps & React$1.RefAttributes<HTMLLIElement>>;
+
+/**
+ * Kanban — flex container for board columns.
+ * Ports `.kanban` / `.kanban-col` / `.kanban-card` from `_shared.css`
+ * (lines 700-778). API per `from-lighttaxes-claude.md` line 81-84.
+ */
+type KanbanProps = React.HTMLAttributes<HTMLDivElement>;
+declare const Kanban: React$1.ForwardRefExoticComponent<KanbanProps & React$1.RefAttributes<HTMLDivElement>>;
+interface KanbanColumnProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title"> {
+    title: string;
+    count: number;
+}
+declare const KanbanColumn: React$1.ForwardRefExoticComponent<KanbanColumnProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const kanbanCardVariants: (props?: ({
+    variant?: "default" | "pro" | "danger" | "warn" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface KanbanCardProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof kanbanCardVariants> {
+}
+declare const KanbanCard: React$1.ForwardRefExoticComponent<KanbanCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Toolbar — horizontal row of controls used above lists, dashboards, etc.
+ * Ports `.toolbar` from `_shared.css` (lines 591-633). FilterChip is a
+ * simpler atom than `MultiFilterPill` — single filter, not multi-select.
+ */
+type ToolbarProps = React.HTMLAttributes<HTMLDivElement>;
+declare const Toolbar: React$1.ForwardRefExoticComponent<ToolbarProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const filterChipVariants: (props?: ({
+    active?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface FilterChipProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof VariantProps<typeof filterChipVariants>>, VariantProps<typeof filterChipVariants> {
+    count?: number;
+}
+declare const FilterChip: React$1.ForwardRefExoticComponent<FilterChipProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Intent-named action wrappers (Phase 4).
+ *
+ * Thin wrappers over Button / LinkButton. Bake in the right variant + size
+ * so the correct call is shorter than the raw call.
+ *
+ * Note: `Button` has no `variant="icon"`. `IconAction` uses `variant="ghost"`
+ * + `size="icon"` (the existing icon size token).
+ */
+type LinkButtonProps = React.ComponentProps<typeof LinkButton>;
+interface PrimaryActionProps extends Omit<ButtonProps, "variant" | "size"> {
+    arrow?: boolean;
+}
+declare const PrimaryAction: React$1.ForwardRefExoticComponent<PrimaryActionProps & React$1.RefAttributes<HTMLButtonElement>>;
+type SecondaryActionProps = Omit<ButtonProps, "variant" | "size">;
+declare const SecondaryAction: React$1.ForwardRefExoticComponent<SecondaryActionProps & React$1.RefAttributes<HTMLButtonElement>>;
+interface DangerActionProps extends Omit<ButtonProps, "variant" | "size" | "onClick"> {
+    /** Required — explicit name forces the consumer to acknowledge intent. */
+    onConfirm: () => void;
+}
+declare const DangerAction: React$1.ForwardRefExoticComponent<DangerActionProps & React$1.RefAttributes<HTMLButtonElement>>;
+interface IconActionProps extends Omit<ButtonProps, "variant" | "size"> {
+    /** Required — icon-only buttons must announce themselves to assistive tech. */
+    "aria-label": string;
+}
+declare const IconAction: React$1.ForwardRefExoticComponent<IconActionProps & React$1.RefAttributes<HTMLButtonElement>>;
+interface LinkActionProps extends Omit<LinkButtonProps, "variant" | "size"> {
+    arrow?: boolean;
+}
+declare const LinkAction: React$1.ForwardRefExoticComponent<Omit<LinkActionProps, "ref"> & React$1.RefAttributes<HTMLAnchorElement>>;
+
+/**
+ * Intent-named atom wrappers (Phase 4).
+ *
+ * Thin <span>/<div>/<kbd> wrappers that bake in the right typography +
+ * color tokens. Compose with the addressable utility classes in tokens.css
+ * (`.tabular`, `.font-spec`, `.eyebrow`, `.eyebrow-num`).
+ */
+type NumericProps = React.HTMLAttributes<HTMLSpanElement>;
+declare const Numeric: React$1.ForwardRefExoticComponent<NumericProps & React$1.RefAttributes<HTMLSpanElement>>;
+type MutedSpecProps = React.HTMLAttributes<HTMLSpanElement>;
+declare const MutedSpec: React$1.ForwardRefExoticComponent<MutedSpecProps & React$1.RefAttributes<HTMLSpanElement>>;
+interface EyebrowProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** When true, switches to spec font + Pro purple (the `01 — Today` pattern). */
+    numeric?: boolean;
+}
+declare const Eyebrow: React$1.ForwardRefExoticComponent<EyebrowProps & React$1.RefAttributes<HTMLDivElement>>;
+type KbdHintProps = React.HTMLAttributes<HTMLElement>;
+declare const KbdHint: React$1.ForwardRefExoticComponent<KbdHintProps & React$1.RefAttributes<HTMLElement>>;
 
 declare function cn(...inputs: ClassValue[]): string;
 
-export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Alert, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle, AlertDialogTrigger, AlertTitle, AlertTriangleIcon, ArrowLeftIcon, ArrowRightIcon, ArrowRightSmallIcon, AspectRatio, AtSignIcon, Avatar, Badge, BarChartIcon, BellIcon, Blockquote, Breadcrumb, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, BuildingIcon, Button, Calendar, CalendarIcon, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, ChatBubbleIcon, CheckIcon, Checkbox, ChevronDownIcon, ChevronLeftIcon, ChevronRightIcon, ChevronUpIcon, ClientSelect, type ClientSelectOption, ClipboardCheckIcon, ClockIcon, CloseIcon, Collapsible, CollapsibleContent, CollapsibleTrigger, ComingSoon, type CommandItem, CommandPalette, ContextMenu, ContextMenuContent, ContextMenuItem, ContextMenuSeparator, ContextMenuTrigger, CopyButton, CopyIcon, CreditCardIcon, DATE_DISPLAY_PLACEHOLDER, DatePicker, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, DialogTrigger, DocumentIcon, DownloadIcon, DropdownMenu, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuTrigger, EmptyState, EyeIcon, FileIcon, FileReturnIcon, FileTextIcon, FileUpload, FlagIcon, FolderClosedIcon, FolderOpenIcon, FolderPlusIcon, FormError, FormSuccess, GlobeIcon, HoverCard, HoverCardContent, HoverCardTrigger, Input, KeyIcon, KeyboardShortcutsDialog, Label, LayoutDashboardIcon, LayoutGridIcon, LayoutListIcon, LightningIcon, Link2Icon, LinkButton, LinkIcon, LockIcon, LockKeyholeIcon, LockOpenIcon, LogOutIcon, Logo, MailIcon, MapPinIcon, MenuIcon, MessageCircleIcon, MessageCircleWarningIcon, MonitorIcon, MoonIcon, MoreHorizontalIcon, MoveIcon, MultiFilterPill, MultiSelectField, OTPInput, Pagination, PaletteIcon, PanelLeftCloseIcon, PanelLeftIcon, PaperclipIcon, PenSignIcon, PencilIcon, PhoneIcon, PhoneInput, PlusIcon, Popover, PopoverContent, PopoverTrigger, ProgressBar, ProgressRing, RadioGroup, RadioGroupItem, ReceiptIcon, RotateCcwIcon, ScrollArea, SearchIcon, SearchInput, SearchSelect, type SearchSelectOption, Section, SectionHeader, Select, SelectContent, SelectTrigger, SendIcon, Separator, SettingsIcon, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetTitle, SheetTrigger, ShieldIcon, SideDrawer, Skeleton, SkeletonCircle, SkeletonText, Slider, SmartphoneIcon, SparkleIcon, StarIcon, StarRating, Stat, Stepper, SubmitButton, SunIcon, Switch, Table, TableBody, TableCaption, TableCell, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, TagIcon, TeamIcon, TeamMemberSelect, Textarea, ToastProvider, ToggleGroup, ToggleGroupItem, Tooltip, TooltipContent, TooltipTrigger, TrashIcon, UploadIcon, UserCircleIcon, UsersIcon, VisuallyHidden, WorkflowIcon, XIcon, ZoomInIcon, ZoomOutIcon, cn, displayToIso, isoToDisplay, useToast };
+export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, type ActivityDotVariant, ActivityItem, type ActivityItemProps, ActivityList, type ActivityListProps, Alert, AlertCircleIcon, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, type AlertProps, AlertTitle, AlertTriangleIcon, AppHeader, AppHeaderActions, type AppHeaderActionsProps, AppHeaderBreadcrumb, type AppHeaderBreadcrumbProps, type AppHeaderProps, AppHeaderSearch, type AppHeaderSearchProps, AppHeaderTitle, type AppHeaderTitleProps, ArrowDownIcon, ArrowLeftIcon, ArrowRightIcon, ArrowRightSmallIcon, ArrowUpIcon, AspectRatio, AtSignIcon, Avatar, Badge, type BadgeProps, BarChartIcon, BellIcon, Blockquote, BoldIcon, Breadcrumb, BreadcrumbItem, type BreadcrumbItemProps, BreadcrumbLink, type BreadcrumbLinkProps, BreadcrumbList, type BreadcrumbListProps, BreadcrumbPage, type BreadcrumbPageProps, type BreadcrumbProps, BreadcrumbSeparator, type BreadcrumbSeparatorProps, BriefcaseIcon, Building2Icon, BuildingIcon, Button, type ButtonProps, Calendar, type CalendarHighlight, type CalendarHighlightColor, CalendarIcon, type CalendarProps, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, type CardVariants, ChatBubbleIcon, CheckCircle2Icon, CheckIcon, Checkbox, ChevronDownIcon, ChevronLeftIcon, ChevronRightIcon, ChevronUpIcon, ChevronsUpDownIcon, CircleDotIcon, CircleIcon, ClientSelect, type ClientSelectOption, ClipboardCheckIcon, ClockIcon, CloseIcon, Collapsible, CollapsibleContent, CollapsibleTrigger, ComingSoon, type ComingSoonProps, CommandIcon, type CommandItem, CommandPalette, ConfirmActionButton, type ConfirmActionButtonProps, Content, type ContentProps, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, CopyButton, CopyIcon, CornerDownLeftIcon, CreditCardIcon, DATE_DISPLAY_PLACEHOLDER, DangerAction, type DangerActionProps, DataTable, DataTableBody, type DataTableBodyProps, DataTableCell, DataTableCellDue, type DataTableCellDueProps, DataTableCellId, DataTableCellMono, DataTableCellName, type DataTableCellProps, DataTableCheckbox, type DataTableCheckboxProps, DataTableHead, type DataTableHeadProps, DataTableHeader, type DataTableHeaderProps, DataTablePagination, type DataTablePaginationProps, type DataTableProps, DataTableResultsCount, type DataTableResultsCountProps, DataTableRow, type DataTableRowProps, DataTableSearch, type DataTableSearchProps, DataTableSpacer, type DataTableSpacerProps, DataTableToolbar, type DataTableToolbarProps, DatePicker, DetailGrid, type DetailGridProps, DetailMain, type DetailMainProps, DetailSpine, DetailSpineHeader, type DetailSpineHeaderProps, type DetailSpineProps, DetailSpineSection, type DetailSpineSectionProps, DetailSpineStats, type DetailSpineStatsProps, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DismissibleChip, DocumentIcon, DollarSignIcon, DownloadIcon, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EmptyState, type EmptyStateProps, EyeIcon, EyeOffIcon, Eyebrow, type EyebrowProps, FileIcon, FileReturnIcon, FileTextIcon, FileUpload, FilterChip, type FilterChipProps, FilterIcon, FlagIcon, FolderClosedIcon, FolderOpenIcon, FolderPlusIcon, FormError, FormSuccess, GlobeIcon, GoogleBrandIcon, HelpCircleIcon, HistoryIcon, HomeIcon, HoverCard, HoverCardContent, HoverCardPortal, HoverCardTrigger, IconAction, type IconActionProps, InboxIcon, InfoIcon, Input, type InputVariants, ItalicIcon, Kanban, KanbanCard, type KanbanCardProps, KanbanColumn, type KanbanColumnProps, KanbanIcon, type KanbanProps, KbdHint, type KbdHintProps, KeyIcon, KeyboardShortcutsDialog, Label, LayoutDashboardIcon, LayoutGridIcon, LayoutListIcon, LightningIcon, Link2Icon, LinkAction, type LinkActionProps, LinkButton, LinkIcon, ListChecksIcon, ListIcon, ListOrderedIcon, LoaderIcon, LockIcon, LockKeyholeIcon, LockOpenIcon, LogOutIcon, Logo, MailIcon, Main, type MainProps, MapPinIcon, MenuIcon, MessageCircleIcon, MessageCircleWarningIcon, MicrosoftBrandIcon, MinusIcon, MonitorIcon, MoonIcon, MoreHorizontalIcon, MoveIcon, MultiFilterPill, MultiSelectField, MutedSpec, type MutedSpecProps, Numeric, type NumericProps, OTPInput, PageHeader, type PageHeaderProps, PageHeaderSep, type PageHeaderSepProps, PageHeaderSpec, type PageHeaderSpecProps, Pagination, type PaginationProps, PaletteIcon, PanelLeftCloseIcon, PanelLeftIcon, PaperclipIcon, PenSignIcon, PencilIcon, PhoneIcon, PhoneInput, PlusIcon, Popover, PopoverAnchor, PopoverClose, PopoverContent, PopoverPortal, PopoverTrigger, PrimaryAction, type PrimaryActionProps, ProgressBar, type ProgressBarProps, ProgressRing, type ProgressRingProps, RadioGroup, RadioGroupItem, ReceiptIcon, ReplyIcon, RotateCcwIcon, SaveIcon, ScrollArea, ScrollBar, SearchIcon, SearchInput, type SearchInputVariants, SearchSelect, type SearchSelectOption, SecondaryAction, type SecondaryActionProps, Section, SectionHead, SectionHeader, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, type SelectOption, type SelectProps, SelectRoot, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, SendIcon, Separator, SettingsIcon, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, Shell, type ShellProps, ShieldIcon, SideDrawer, Sidebar, SidebarBrand, type SidebarBrandProps, SidebarBrandText, type SidebarBrandTextProps, SidebarFooter, type SidebarFooterProps, SidebarLink, SidebarLinkAction, type SidebarLinkActionProps, SidebarLinkBadge, type SidebarLinkBadgeProps, type SidebarLinkBadgeVariants, SidebarLinkGroup, type SidebarLinkGroupProps, SidebarLinkLabel, type SidebarLinkLabelProps, type SidebarLinkProps, type SidebarProps, SidebarProvider, type SidebarProviderProps, SidebarSection, type SidebarSectionProps, type SidebarState, SidebarTrigger, type SidebarTriggerProps, SidebarUser, type SidebarUserProps, Skeleton, SkeletonCircle, SkeletonText, SlashIcon, Slider, SmartphoneIcon, type SortDirection, SparkleIcon, SparklesIcon, StarIcon, StarRating, type StarRatingProps, Stat, type Step, Stepper, type StepperProps, StrikethroughIcon, SubmitButton, SunIcon, Switch, Table, TableBody, type TableBodyProps, TableCaption, type TableCaptionProps, TableCell, type TableCellProps, TableFooter, type TableFooterProps, TableHead, type TableHeadProps, TableHeader, type TableHeaderProps, TableIcon, type TableProps, TableRow, type TableRowProps, Tabs, TabsContent, TabsList, TabsTrigger, TagIcon, TeamIcon, TeamMemberSelect, Textarea, type TextareaVariants, ToastProvider, ToggleGroup, ToggleGroupItem, Toolbar, type ToolbarProps, Tooltip, TooltipContent, TooltipPortal, TooltipProvider, TooltipTrigger, Trash2Icon, TrashIcon, UnderlineIcon, UploadIcon, UserCircleIcon, UserIcon, UsersIcon, VisuallyHidden, WorkflowIcon, XIcon, ZoomInIcon, ZoomOutIcon, alertVariants, badgeVariants, buttonVariants, cardVariants, cn, displayToIso, filterChipVariants, inputVariants, isoToDisplay, kanbanCardVariants, labelVariants, progressBarVariants, progressRingVariants, searchInputVariants, sidebarLinkBadgeVariants, starRatingVariants, textareaVariants, useSidebarState, useToast };