@cocliny/ui-library 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1346 @@
+import { ClassValue } from 'clsx';
+export { ClassValue } from 'clsx';
+import * as react from 'react';
+import { CSSProperties, ElementType, PropsWithChildren, ComponentPropsWithoutRef, ComponentPropsWithRef, ReactNode, AriaAttributes, HTMLAttributes } from 'react';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as ToastPrimitives from '@radix-ui/react-toast';
+import { DayPicker, DateRange } from 'react-day-picker';
+import * as react_hook_form from 'react-hook-form';
+import { FieldValues, FieldPath, ControllerProps } from 'react-hook-form';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+import { ColumnDef } from '@tanstack/react-table';
+export { ColumnDef } from '@tanstack/react-table';
+
+/**
+ * `cn` — the framework's single class-composition helper.
+ * clsx handles conditional composition; tailwind-merge resolves conflicts so
+ * the LAST class wins — which is what makes every component's `className`
+ * prop a true override rather than a lottery.
+ */
+
+declare function cn(...inputs: ClassValue[]): string;
+
+/**
+ * `defineVariants` — a strongly-typed variant engine (base + variants +
+ * compoundVariants + defaultVariants), hand-rolled so the framework carries no
+ * extra runtime dependency. API mirrors the industry-standard cva shape, so
+ * migrating to cva later would be mechanical.
+ *
+ * @example
+ * const button = defineVariants({
+ *   base: "inline-flex items-center focus-ring",
+ *   variants: {
+ *     intent: { primary: "bg-primary text-primary-fg", danger: "bg-danger text-danger-fg" },
+ *     size: { sm: "h-(--ml-control-h-sm)", md: "h-(--ml-control-h-md)" },
+ *   },
+ *   compoundVariants: [{ intent: "danger", size: "sm", className: "font-semibold" }],
+ *   defaultVariants: { intent: "primary", size: "md" },
+ * });
+ * button({ size: "sm" }); // → merged class string
+ * type ButtonVariantProps = VariantProps<typeof button>;
+ */
+
+type VariantsSchema = Record<string, Record<string, ClassValue>>;
+type BooleanIfBoolKeys<TMap> = "true" extends keyof TMap ? boolean : never;
+type VariantSelection<TVariants extends VariantsSchema> = {
+    [K in keyof TVariants]?: keyof TVariants[K] | BooleanIfBoolKeys<TVariants[K]>;
+};
+type CompoundVariant<TVariants extends VariantsSchema> = VariantSelection<TVariants> & {
+    className: ClassValue;
+};
+interface VariantsConfig<TVariants extends VariantsSchema> {
+    base?: ClassValue;
+    variants: TVariants;
+    compoundVariants?: ReadonlyArray<CompoundVariant<TVariants>>;
+    defaultVariants?: VariantSelection<TVariants>;
+}
+type VariantFn<TVariants extends VariantsSchema> = (selection?: VariantSelection<TVariants> & {
+    className?: ClassValue;
+}) => string;
+/** Extracts the props type of a variant function for reuse in component props. */
+type VariantProps<T> = T extends VariantFn<infer V> ? VariantSelection<V> : never;
+declare function defineVariants<TVariants extends VariantsSchema>(config: VariantsConfig<TVariants>): VariantFn<TVariants>;
+
+/**
+ * Shared vocabulary types used across every component's public API.
+ * Keeping these in one module guarantees the whole framework speaks the same
+ * language for sizes, intents, radii, and density.
+ */
+
+/** Standard component size scale. Components may support a subset. */
+type Size = "xs" | "sm" | "md" | "lg" | "xl";
+/** Semantic intent — maps 1:1 onto the semantic color tokens. */
+type Intent = "neutral" | "primary" | "success" | "warning" | "danger" | "info";
+/** Corner radius scale — maps onto the --radius-* tokens. */
+type Radius = "xs" | "sm" | "md" | "lg" | "xl" | "pill";
+/** Layout density — maps onto [data-density]. */
+type Density = "comfortable" | "compact";
+/** Color scheme selection. `system` follows prefers-color-scheme. */
+type ColorScheme = "light" | "dark" | "system";
+/** A concrete, resolved scheme (never `system`). */
+type ResolvedColorScheme = Exclude<ColorScheme, "system">;
+/**
+ * Props every framework component accepts. Spread `...rest` is additionally
+ * allowed per component, but these are guaranteed everywhere.
+ */
+interface CommonProps {
+    /** Extra classes, merged override-safe (consumer classes win). */
+    className?: string;
+    /** Inline style escape hatch. */
+    style?: CSSProperties;
+    id?: string;
+    /** Stable hook for tests and analytics. */
+    "data-testid"?: string;
+}
+
+/**
+ * Polymorphic component machinery: strongly-typed `as` prop support so
+ * components like <Text as="label" htmlFor=…> get full IntelliSense for the
+ * rendered element's attributes, with `ref` typed to match.
+ */
+
+type AsProp<C extends ElementType> = {
+    /** Element or component to render as. */
+    as?: C;
+};
+type OmitConflicts<C extends ElementType, P> = keyof (AsProp<C> & P);
+/** Public props of a polymorphic component (no ref). */
+type PolymorphicProps<C extends ElementType, P = object> = PropsWithChildren<P & AsProp<C>> & Omit<ComponentPropsWithoutRef<C>, OmitConflicts<C, P>>;
+/** Correctly-typed ref for the rendered element. */
+type PolymorphicRef<C extends ElementType> = ComponentPropsWithRef<C>["ref"];
+/** Props of a polymorphic component including its ref. */
+type PolymorphicPropsWithRef<C extends ElementType, P = object> = PolymorphicProps<C, P> & {
+    ref?: PolymorphicRef<C>;
+};
+
+/**
+ * Slot & render-hook typing. Complex components expose named slots; consumers
+ * override per-slot classes/styles without touching framework code, and can
+ * replace whole regions through render hooks.
+ */
+
+/** Per-slot className overrides, e.g. `classNames={{ root: "…", header: "…" }}`. */
+type SlotClassNames<TSlot extends string> = Partial<Record<TSlot, string>>;
+/** Per-slot inline-style overrides. */
+type SlotStyles<TSlot extends string> = Partial<Record<TSlot, CSSProperties>>;
+/**
+ * A render hook: receives the default node plus the component's context, and
+ * returns what to actually render. Returning `defaultNode` unchanged keeps the
+ * built-in rendering, so hooks compose with zero cost when unused.
+ */
+type RenderHook<TContext = void> = (defaultNode: ReactNode, context: TContext) => ReactNode;
+/** Standard slot-override props for components with named slots. */
+interface SlottableProps<TSlot extends string> {
+    /** Class overrides per named slot. Merged override-safe after framework classes. */
+    classNames?: SlotClassNames<TSlot>;
+    /** Inline-style overrides per named slot. */
+    styles?: SlotStyles<TSlot>;
+}
+
+/**
+ * Typed mirror of the semantic token surface declared in styles/index.css.
+ * `ThemeOverrides` is the public rebranding API: every key maps to one --ml-*
+ * CSS variable. Adding a token means adding it in exactly two places — the
+ * CSS `:root` block and this map — and the type system covers the rest.
+ */
+/** Semantic token name → CSS custom-property it controls. */
+declare const TOKEN_CSS_VARS: {
+    readonly background: "--ml-background";
+    readonly surface: "--ml-surface";
+    readonly surfaceRaised: "--ml-surface-raised";
+    readonly surfaceSunken: "--ml-surface-sunken";
+    readonly overlay: "--ml-overlay";
+    readonly border: "--ml-border";
+    readonly borderStrong: "--ml-border-strong";
+    readonly fg: "--ml-fg";
+    readonly fgMuted: "--ml-fg-muted";
+    readonly fgSubtle: "--ml-fg-subtle";
+    readonly fgDisabled: "--ml-fg-disabled";
+    readonly fgInverted: "--ml-fg-inverted";
+    readonly primary: "--ml-primary";
+    readonly primaryHover: "--ml-primary-hover";
+    readonly primaryActive: "--ml-primary-active";
+    readonly primaryFg: "--ml-primary-fg";
+    readonly primarySubtle: "--ml-primary-subtle";
+    readonly primarySubtleFg: "--ml-primary-subtle-fg";
+    readonly success: "--ml-success";
+    readonly successFg: "--ml-success-fg";
+    readonly successSubtle: "--ml-success-subtle";
+    readonly successSubtleFg: "--ml-success-subtle-fg";
+    readonly warning: "--ml-warning";
+    readonly warningFg: "--ml-warning-fg";
+    readonly warningSubtle: "--ml-warning-subtle";
+    readonly warningSubtleFg: "--ml-warning-subtle-fg";
+    readonly danger: "--ml-danger";
+    readonly dangerFg: "--ml-danger-fg";
+    readonly dangerSubtle: "--ml-danger-subtle";
+    readonly dangerSubtleFg: "--ml-danger-subtle-fg";
+    readonly info: "--ml-info";
+    readonly infoFg: "--ml-info-fg";
+    readonly infoSubtle: "--ml-info-subtle";
+    readonly infoSubtleFg: "--ml-info-subtle-fg";
+    readonly focusRing: "--ml-focus-ring";
+    readonly focusRingWidth: "--ml-focus-ring-width";
+    readonly focusRingOffset: "--ml-focus-ring-offset";
+    readonly durationFast: "--ml-duration-fast";
+    readonly durationNormal: "--ml-duration-normal";
+    readonly durationSlow: "--ml-duration-slow";
+};
+/** All override-able semantic token names. */
+type ThemeToken = keyof typeof TOKEN_CSS_VARS;
+/** Per-token value overrides (any valid CSS value for that property). */
+type TokenValues = Partial<Record<ThemeToken, string>>;
+/**
+ * Rebranding payload accepted by ThemeProvider. `light` applies to :root,
+ * `dark` to [data-theme="dark"]; `common` applies to both.
+ */
+interface ThemeOverrides {
+    common?: TokenValues;
+    light?: TokenValues;
+    dark?: TokenValues;
+}
+
+/**
+ * Serialization of ThemeOverrides into CSS. Pure — unit-testable and usable
+ * server-side (the ThemeProvider renders the result into a <style> tag, so
+ * SSR output already carries the brand with no flash of default theme).
+ */
+
+/**
+ * Builds the stylesheet text for a set of overrides. Scoped under a selector
+ * (default `:root`) so multiple branded regions can coexist if ever needed.
+ */
+declare function themeOverridesToCss(overrides: ThemeOverrides, scope?: string): string;
+
+interface ThemeContextValue {
+    /** The selected scheme, possibly `system`. */
+    colorScheme: ColorScheme;
+    /** The scheme actually in effect (system resolved). */
+    resolvedColorScheme: ResolvedColorScheme;
+    setColorScheme: (scheme: ColorScheme) => void;
+    density: Density;
+    setDensity: (density: Density) => void;
+}
+interface ThemeProviderProps {
+    children: ReactNode;
+    /** Initial scheme when nothing is persisted. @default "system" */
+    defaultColorScheme?: ColorScheme;
+    /** Initial density. @default "comfortable" */
+    defaultDensity?: Density;
+    /** Brand token overrides — the rebranding API. */
+    overrides?: ThemeOverrides;
+    /**
+     * localStorage key for the persisted scheme; pass `null` to disable
+     * persistence entirely. @default "ml-color-scheme"
+     */
+    storageKey?: string | null;
+}
+declare function ThemeProvider({ children, defaultColorScheme, defaultDensity, overrides, storageKey, }: ThemeProviderProps): react.JSX.Element;
+/** Access the theme runtime. Throws outside a ThemeProvider. */
+declare function useTheme(): ThemeContextValue;
+/**
+ * Inline script for the document <head> that applies the persisted (or
+ * system) scheme BEFORE first paint, eliminating theme flash on SSR pages:
+ *
+ * ```tsx
+ * <script dangerouslySetInnerHTML={{ __html: getThemeInitScript() }} />
+ * ```
+ */
+declare function getThemeInitScript(storageKey?: string): string;
+
+type TextSize = "xs" | "sm" | "md" | "lg" | "xl";
+type TextWeight = "regular" | "medium" | "semibold" | "bold";
+type TextTone = "default" | "muted" | "subtle" | "disabled" | "danger" | "success" | "inverted";
+type TextAlign = "left" | "center" | "right";
+interface TextOwnProps {
+    size?: TextSize;
+    weight?: TextWeight;
+    tone?: TextTone;
+    align?: TextAlign;
+    /** Single-line ellipsis truncation. */
+    truncate?: boolean;
+    className?: string;
+}
+type TextProps<C extends ElementType = "span"> = PolymorphicProps<C, TextOwnProps>;
+
+/**
+ * Polymorphic text primitive — the base of the typography system. Renders a
+ * <span> by default; any element/component via `as` with full prop typing.
+ *
+ * @example
+ * <Text size="sm" tone="muted" truncate>{patient.summary}</Text>
+ * <Text as="label" htmlFor="dob" weight="semibold">Date of birth</Text>
+ */
+declare function Text<C extends ElementType = "span">(props: TextProps<C>): react.JSX.Element;
+
+type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+type HeadingSize = "xs" | "sm" | "md" | "lg" | "xl" | "2xl";
+interface HeadingOwnProps {
+    /** Semantic heading level (h1–h6). Visual size is independent via `size`. */
+    level?: HeadingLevel;
+    /** Visual size, decoupled from the semantic level. */
+    size?: HeadingSize;
+    className?: string;
+}
+type HeadingProps<C extends ElementType = "h2"> = PolymorphicProps<C, HeadingOwnProps>;
+/**
+ * Semantic heading with size decoupled from level — correct document outline
+ * without giant fonts (e.g. `level={2} size="sm"` for a card title).
+ */
+declare function Heading<C extends ElementType = "h2">(props: HeadingProps<C>): react.JSX.Element;
+
+interface LabelProps extends ComponentPropsWithoutRef<"label"> {
+    /** Renders a required marker (with sr-only text for screen readers). */
+    required?: boolean;
+}
+/** Form label with consistent weight/size and an accessible required marker. */
+declare function Label({ required, className, children, ...rest }: LabelProps): react.JSX.Element;
+
+interface CodeProps extends ComponentPropsWithoutRef<"code"> {
+    /** Render as a block (<pre><code>) instead of inline. */
+    block?: boolean;
+}
+/** Inline code chip, or a scrollable code block with `block`. */
+declare function Code({ block, className, children, ...rest }: CodeProps): react.JSX.Element;
+
+interface LinkOwnProps {
+    variant?: "default" | "underline" | "inherit";
+    className?: string;
+}
+type LinkProps<C extends ElementType = "a"> = PolymorphicProps<C, LinkOwnProps>;
+/**
+ * Anchor styling over any link implementation. Framework-agnostic by design:
+ * pass your router's component via `as` (e.g. `as={NextLink}`) — the framework
+ * never owns routing.
+ */
+declare function Link<C extends ElementType = "a">(props: LinkProps<C>): react.JSX.Element;
+
+type ButtonVariant = "solid" | "outline" | "ghost" | "subtle";
+type ButtonIntent = "primary" | "neutral" | "success" | "warning" | "danger";
+type ButtonSize = "sm" | "md" | "lg";
+interface ButtonProps extends ComponentPropsWithoutRef<"button"> {
+    variant?: ButtonVariant;
+    intent?: ButtonIntent;
+    size?: ButtonSize;
+    /** Shows a spinner, sets aria-busy, and blocks activation. */
+    loading?: boolean;
+    /** Icon before the label. Sized by the button. */
+    startIcon?: ReactNode;
+    /** Icon after the label. */
+    endIcon?: ReactNode;
+    /** Stretch to the container width. */
+    fullWidth?: boolean;
+}
+
+/**
+ * The framework button. Variant (fill treatment) × intent (semantic color) ×
+ * size (density-aware height). `loading` swaps the start icon for a spinner,
+ * sets aria-busy, and blocks activation while keeping the label visible —
+ * layout never jumps.
+ *
+ * @example
+ * <Button intent="danger" variant="outline" onClick={onDelete}>Delete</Button>
+ * <Button loading={saving} onClick={onSave}>Save changes</Button>
+ */
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface IconButtonProps extends Omit<ButtonProps, "startIcon" | "endIcon" | "children" | "fullWidth"> {
+    /** The icon to render. */
+    icon: ReactNode;
+    /** REQUIRED accessible name — icon-only controls are invisible to AT without it. */
+    "aria-label": string;
+}
+/**
+ * Square icon-only button. Reuses every Button variant/intent/size; the
+ * accessible name is enforced at the type level.
+ */
+declare const IconButton: react.ForwardRefExoticComponent<IconButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface ButtonGroupProps extends ComponentPropsWithoutRef<"div"> {
+    /** Accessible name for the group. */
+    "aria-label": string;
+}
+/**
+ * Visually joins adjacent buttons into one segmented control: inner corners
+ * squared, borders collapsed. Works with any Button variant.
+ */
+declare function ButtonGroup({ className, children, ...rest }: ButtonGroupProps): react.JSX.Element;
+
+interface SpinnerProps {
+    size?: "xs" | "sm" | "md" | "lg";
+    /**
+     * Accessible label. Pass null ONLY when a parent already announces loading
+     * (e.g. a button with aria-busy) — the spinner is then presentation-only.
+     */
+    label?: string | null;
+    className?: string;
+}
+/** Indeterminate activity indicator. Inherits color from its context. */
+declare function Spinner({ size, label, className }: SpinnerProps): react.JSX.Element;
+
+interface SkeletonProps extends ComponentPropsWithoutRef<"div"> {
+    /** Shape preset. `text` renders at 1em so it matches surrounding line-height. */
+    variant?: "rect" | "text" | "circle";
+}
+/**
+ * Loading placeholder. aria-hidden by design: pair the REGION with aria-busy
+ * on the container so screen readers hear one busy state, not N skeletons.
+ */
+declare function Skeleton({ variant, className, ...rest }: SkeletonProps): react.JSX.Element;
+
+type AlertIntent = "info" | "success" | "warning" | "danger";
+interface AlertProps extends Omit<ComponentPropsWithoutRef<"div">, "title"> {
+    intent?: AlertIntent;
+    /** Bold first line. */
+    title?: ReactNode;
+    /** Leading icon slot. */
+    icon?: ReactNode;
+    /** Trailing actions slot (buttons, dismiss). */
+    actions?: ReactNode;
+}
+/**
+ * Inline callout for statuses and outcomes. Danger/warning announce
+ * assertively (role=alert); info/success use role=status.
+ */
+declare function Alert({ intent, title, icon, actions, className, children, ...rest }: AlertProps): react.JSX.Element;
+
+interface ProgressProps extends Omit<ComponentPropsWithoutRef<"div">, "role"> {
+    /** Current value; omit for indeterminate. */
+    value?: number;
+    max?: number;
+    /** Accessible name for the bar. */
+    "aria-label": string;
+    size?: "sm" | "md";
+}
+/** Determinate/indeterminate progress bar with correct progressbar semantics. */
+declare function Progress({ value, max, size, className, ...rest }: ProgressProps): react.JSX.Element;
+
+interface StatusIndicatorProps extends ComponentPropsWithoutRef<"span"> {
+    intent?: Intent;
+    /** Hide the leading color dot. */
+    withDot?: boolean;
+}
+/**
+ * Semantic status pill (tinted fill + matching text + color dot) — the
+ * standard rendering for workflow states across clinical tables and headers.
+ */
+declare function StatusIndicator({ intent, withDot, className, children, ...rest }: StatusIndicatorProps): react.JSX.Element;
+
+interface EmptyStateProps extends Omit<ComponentPropsWithoutRef<"div">, "title"> {
+    /** One-line headline ("No sessions yet"). */
+    title: ReactNode;
+    /** Supporting copy explaining why / what to do next. */
+    description?: ReactNode;
+    /** Illustration / icon slot. */
+    icon?: ReactNode;
+    /** Call-to-action slot (typically a Button). */
+    actions?: ReactNode;
+}
+/** Centered empty-state block for lists, tables, and panels with no data. */
+declare function EmptyState({ title, description, icon, actions, className, ...rest }: EmptyStateProps): react.JSX.Element;
+/** ErrorState — EmptyState preset for failed loads. role=alert announces it. */
+declare function ErrorState(props: EmptyStateProps): react.JSX.Element;
+/** SuccessState — EmptyState preset for completed flows. */
+declare function SuccessState(props: EmptyStateProps): react.JSX.Element;
+
+interface LoadingOverlayProps extends ComponentPropsWithoutRef<"div"> {
+    /** Overlay renders (and blocks interaction) only while true. */
+    visible: boolean;
+    /** Accessible + visible loading text. */
+    label?: string;
+}
+/**
+ * Absolute overlay that dims and blocks its nearest positioned ancestor while
+ * `visible` — wrap the region in `relative`. Content stays mounted (no layout
+ * loss), which is the right pattern for refresh-in-place.
+ */
+declare function LoadingOverlay({ visible, label, className, ...rest }: LoadingOverlayProps): react.JSX.Element | null;
+
+declare const Dialog: react.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: react.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: react.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: react.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & react.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & react.RefAttributes<HTMLHeadingElement>, "ref"> & react.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & react.RefAttributes<HTMLParagraphElement>, "ref"> & react.RefAttributes<HTMLParagraphElement>>;
+
+/**
+ * Drawer — a modal panel that slides in from an edge of the viewport.
+ * Built on the same Radix Dialog behavior as `Dialog` (focus trap, Escape,
+ * overlay dismiss, aria-modal); only the presentation differs. Use it for
+ * mobile navigation, filter panels, and quick-look records.
+ */
+declare const Drawer: react.FC<DialogPrimitive.DialogProps>;
+declare const DrawerTrigger: react.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const DrawerPortal: react.FC<DialogPrimitive.DialogPortalProps>;
+declare const DrawerClose: react.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & react.RefAttributes<HTMLButtonElement>>;
+declare const DrawerOverlay: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const drawerContent: VariantFn<{
+    side: {
+        left: string;
+        right: string;
+        top: string;
+        bottom: string;
+    };
+}>;
+interface DrawerContentProps extends ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof drawerContent> {
+    /** Hide the built-in close button (e.g. when the content provides its own). */
+    hideCloseButton?: boolean;
+}
+declare const DrawerContent: react.ForwardRefExoticComponent<DrawerContentProps & react.RefAttributes<HTMLDivElement>>;
+declare const DrawerHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+    displayName: string;
+};
+declare const DrawerFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+    displayName: string;
+};
+declare const DrawerTitle: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & react.RefAttributes<HTMLHeadingElement>, "ref"> & react.RefAttributes<HTMLHeadingElement>>;
+declare const DrawerDescription: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & react.RefAttributes<HTMLParagraphElement>, "ref"> & react.RefAttributes<HTMLParagraphElement>>;
+
+declare const AlertDialog: react.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: react.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: react.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogTitle: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & react.RefAttributes<HTMLHeadingElement>, "ref"> & react.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & react.RefAttributes<HTMLParagraphElement>, "ref"> & react.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const Popover: react.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: react.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: react.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & react.RefAttributes<HTMLDivElement>>;
+declare const PopoverContent: react.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const TooltipProvider: react.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: react.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: react.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: react.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const ToastProvider: react.FC<ToastPrimitives.ToastProviderProps>;
+declare const ToastViewport: react.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & react.RefAttributes<HTMLOListElement>, "ref"> & react.RefAttributes<HTMLOListElement>>;
+declare const Toast: react.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & react.RefAttributes<HTMLLIElement>, "ref"> & {
+    variant?: "default" | "success" | "danger" | "warning";
+} & react.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: react.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: react.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: react.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: react.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+interface FieldProps extends Omit<ComponentPropsWithoutRef<"div">, "children"> {
+    label: ReactNode;
+    /** Hint below the control. Hidden while an error shows. */
+    description?: ReactNode;
+    /** Validation message; presence marks the control invalid. */
+    error?: ReactNode;
+    required?: boolean;
+    disabled?: boolean;
+    /** The control. It receives id/aria wiring via Field context. */
+    children: ReactNode;
+}
+/**
+ * Form-field wrapper: renders label → control → description/error and wires
+ * htmlFor / aria-describedby / aria-invalid to the child input through
+ * context — one accessible pattern for every input in the framework.
+ * Submission and validation logic stay in the application (RHF/Zod adapters
+ * compose on top; the framework never submits).
+ */
+declare function Field({ label, description, error, required, disabled, className, children, ...rest }: FieldProps): react.JSX.Element;
+
+interface FieldContextValue {
+    inputId: string;
+    descriptionId: string | undefined;
+    errorId: string | undefined;
+    invalid: boolean;
+    required: boolean;
+    disabled: boolean;
+}
+/** Field wiring for the nearest <Field>; null when used standalone. */
+declare function useFieldContext(): FieldContextValue | null;
+/**
+ * Merges Field-provided a11y wiring with an input's own props (own props win).
+ * Inputs call this so they work both inside a <Field> and standalone.
+ */
+declare function useFieldInputProps(own: {
+    id?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: AriaAttributes["aria-invalid"];
+    disabled?: boolean;
+    required?: boolean;
+}): {
+    id: string | undefined;
+    "aria-describedby": string | undefined;
+    "aria-invalid": true | undefined;
+    disabled: boolean | undefined;
+    required: boolean | undefined;
+};
+
+interface TextInputProps extends ComponentPropsWithoutRef<"input"> {
+    /** Leading adornment (icon, prefix text). */
+    startAdornment?: ReactNode;
+    /** Trailing adornment (icon, suffix, action). */
+    endAdornment?: ReactNode;
+}
+/** Shared control shell used by every text-like input for identical chrome. */
+declare const inputClassName: (invalid: boolean, className?: string) => string;
+/**
+ * Single-line text input. Inside a <Field> it inherits id/aria wiring
+ * automatically; standalone it behaves like a styled native input.
+ */
+declare const TextInput: react.ForwardRefExoticComponent<TextInputProps & react.RefAttributes<HTMLInputElement>>;
+
+type PasswordInputProps = Omit<TextInputProps, "type" | "endAdornment">;
+/**
+ * Password input with an accessible show/hide toggle. The toggle is
+ * aria-pressed and never submits the surrounding form.
+ */
+declare const PasswordInput: react.ForwardRefExoticComponent<PasswordInputProps & react.RefAttributes<HTMLInputElement>>;
+
+type SearchInputProps = Omit<TextInputProps, "type" | "startAdornment">;
+/** Search input: type=search semantics + a leading search icon. */
+declare const SearchInput: react.ForwardRefExoticComponent<SearchInputProps & react.RefAttributes<HTMLInputElement>>;
+
+type TextareaProps = ComponentPropsWithoutRef<"textarea">;
+/** Multi-line input with the shared control chrome; vertical resize only. */
+declare const Textarea: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & react.RefAttributes<HTMLTextAreaElement>>;
+
+interface CheckboxProps extends Omit<ComponentPropsWithoutRef<"input">, "type"> {
+    /** Label rendered beside the box (clicking it toggles). */
+    label?: ReactNode;
+    /** Secondary line under the label. */
+    description?: ReactNode;
+}
+/**
+ * Native-input checkbox (real <input type="checkbox"> — free keyboard and
+ * form semantics) with token-driven visuals via accent-color.
+ */
+declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;
+
+interface CodeInputProps {
+    /** Number of digits. @default 6 */
+    length?: number;
+    /** Controlled value (digits typed so far). */
+    value?: string;
+    /** Initial value in uncontrolled mode. */
+    defaultValue?: string;
+    /** Fired on every change with the digits typed so far. */
+    onChange?: (value: string) => void;
+    /** Fired once when all cells are filled. */
+    onComplete?: (value: string) => void;
+    disabled?: boolean;
+    /** Marks the group invalid (e.g. wrong code). */
+    error?: boolean;
+    /** Focus the first cell on mount. */
+    autoFocus?: boolean;
+    /** Accessible name of the group. @default "Verification code" */
+    "aria-label"?: string;
+    /** Form field name; the joined value submits via a hidden input. */
+    name?: string;
+    className?: string;
+}
+/**
+ * Segmented one-time-code entry (MFA, email verification): one cell per
+ * digit with auto-advance, Backspace stepping back, arrow-key movement, and
+ * full-code paste. Submits as a single hidden input when `name` is set.
+ *
+ * @example
+ * <CodeInput length={6} autoFocus onComplete={verify} error={failed} />
+ */
+declare const CodeInput: react.ForwardRefExoticComponent<CodeInputProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SwitchProps extends Omit<ComponentPropsWithoutRef<"input">, "type" | "role"> {
+    label?: ReactNode;
+}
+/**
+ * Toggle switch built on a visually-hidden native checkbox with role=switch —
+ * native keyboard/forms behavior, switch semantics for AT, token-driven track.
+ */
+declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLInputElement>>;
+
+interface RadioOption<TValue extends string> {
+    value: TValue;
+    label: ReactNode;
+    description?: ReactNode;
+    disabled?: boolean;
+}
+interface RadioGroupProps<TValue extends string> {
+    /** Accessible name for the group. */
+    "aria-label"?: string;
+    options: ReadonlyArray<RadioOption<TValue>>;
+    /** Controlled value. */
+    value?: TValue;
+    /** Uncontrolled initial value. */
+    defaultValue?: TValue;
+    onChange?: (value: TValue) => void;
+    /** Shared native name; generated when omitted. */
+    name?: string;
+    orientation?: "vertical" | "horizontal";
+    disabled?: boolean;
+    className?: string;
+}
+/**
+ * Radio group over native inputs — native keyboard behavior (arrows within
+ * the group) and form semantics for free. Controlled or uncontrolled.
+ */
+declare function RadioGroup<TValue extends string>({ options, value, defaultValue, onChange, name, orientation, disabled, className, ...rest }: RadioGroupProps<TValue>): react.JSX.Element;
+
+interface SelectOption<TValue extends string = string> {
+    value: TValue;
+    label: string;
+    disabled?: boolean;
+}
+interface SelectProps extends ComponentPropsWithoutRef<"select"> {
+    /** Options; alternatively pass <option> children. */
+    options?: ReadonlyArray<SelectOption>;
+    /** Placeholder row rendered as a disabled empty-value option. */
+    placeholder?: string;
+}
+/**
+ * Styled NATIVE select — the right default for enterprise forms (OS pickers,
+ * mobile wheels, full a11y for free). A searchable custom Combobox arrives in
+ * Phase 5 for long option lists.
+ */
+declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLSelectElement>>;
+
+type CalendarProps = react.ComponentProps<typeof DayPicker>;
+declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): react.JSX.Element;
+
+interface DatePickerProps {
+    value?: Date;
+    onChange?: (date?: Date) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+}
+declare function DatePicker({ value, onChange, placeholder, disabled, className, }: DatePickerProps): react.JSX.Element;
+
+declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>({ children, watch, getValues, getFieldState, setError, clearErrors, setValue, setValues, trigger, formState, resetField, reset, handleSubmit, unregister, control, register, setFocus, subscribe, }: react_hook_form.FormProviderProps<TFieldValues, TContext, TTransformedValues>) => react.JSX.Element;
+declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => react.JSX.Element;
+declare const FormItem: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const useFormField: () => {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: react_hook_form.FieldError;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+declare const FormLabel: {
+    ({ className, required, ...props }: react.ComponentPropsWithoutRef<typeof LabelPrimitive.Root> & {
+        required?: boolean;
+    }): react.JSX.Element;
+    displayName: string;
+};
+declare const FormControl: react.ForwardRefExoticComponent<Omit<react.HTMLAttributes<HTMLElement> & {
+    children?: react.ReactNode;
+} & react.RefAttributes<HTMLElement>, "ref"> & react.RefAttributes<HTMLElement>>;
+declare const FormDescription: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLParagraphElement> & react.RefAttributes<HTMLParagraphElement>>;
+declare const FormMessage: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLParagraphElement> & react.RefAttributes<HTMLParagraphElement>>;
+
+declare const ToggleGroup: react.ForwardRefExoticComponent<(Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & react.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & react.RefAttributes<HTMLDivElement>, "ref">) & react.RefAttributes<HTMLDivElement>>;
+declare const ToggleGroupItem: react.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & react.RefAttributes<HTMLButtonElement>, "ref"> & {
+    badge?: react.ReactNode;
+} & react.RefAttributes<HTMLButtonElement>>;
+
+interface ComboboxOption {
+    value: string;
+    label: string;
+}
+interface ComboboxProps {
+    options: ComboboxOption[];
+    value?: string;
+    onChange?: (value: string) => void;
+    placeholder?: string;
+    emptyText?: string;
+    className?: string;
+    disabled?: boolean;
+}
+declare function Combobox({ options, value, onChange, placeholder, emptyText, className, disabled, }: ComboboxProps): react.JSX.Element;
+
+interface MultiSelectOption {
+    value: string;
+    label: string;
+}
+interface MultiSelectProps extends Omit<react.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    options: MultiSelectOption[];
+    value: string[];
+    onChange: (value: string[]) => void;
+    placeholder?: string;
+    disabled?: boolean;
+}
+declare const MultiSelect: react.ForwardRefExoticComponent<MultiSelectProps & react.RefAttributes<HTMLDivElement>>;
+
+interface FileUploadProps extends Omit<react.HTMLAttributes<HTMLDivElement>, "onChange" | "onDrop"> {
+    onChange?: (files: File[]) => void;
+    accept?: string;
+    multiple?: boolean;
+    disabled?: boolean;
+    maxSize?: number;
+}
+declare const FileUpload: react.ForwardRefExoticComponent<FileUploadProps & react.RefAttributes<HTMLInputElement>>;
+
+interface DateRangePickerProps {
+    value?: DateRange;
+    onChange?: (date?: DateRange) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+}
+declare function DateRangePicker({ value, onChange, placeholder, disabled, className, }: DateRangePickerProps): react.JSX.Element;
+
+interface SliderProps extends Omit<react.InputHTMLAttributes<HTMLInputElement>, "onChange"> {
+    value?: number;
+    defaultValue?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    onChange?: (value: number) => void;
+    showTicks?: boolean;
+}
+declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<HTMLInputElement>>;
+
+interface SignatureInputProps extends Omit<react.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    onChange?: (signatureDataUrl: string | null) => void;
+    disabled?: boolean;
+}
+declare const SignatureInput: react.ForwardRefExoticComponent<SignatureInputProps & react.RefAttributes<HTMLDivElement>>;
+
+type StackGap = "none" | "xs" | "sm" | "md" | "lg" | "xl";
+type StackAlign = "stretch" | "start" | "center" | "end";
+interface StackOwnProps {
+    direction?: "column" | "row";
+    gap?: StackGap;
+    align?: StackAlign;
+    wrap?: boolean;
+    className?: string;
+}
+type StackProps<C extends ElementType = "div"> = PolymorphicProps<C, StackOwnProps>;
+/** One-dimensional layout: children spaced along a single axis. */
+declare function Stack<C extends ElementType = "div">(props: StackProps<C>): react.JSX.Element;
+
+interface FlexOwnProps {
+    align?: "stretch" | "start" | "center" | "end" | "baseline";
+    justify?: "start" | "center" | "end" | "between" | "around";
+    gap?: StackGap;
+    wrap?: boolean;
+    className?: string;
+}
+type FlexProps<C extends ElementType = "div"> = PolymorphicProps<C, FlexOwnProps>;
+/** Row-oriented flexbox helper: toolbars, header rows, inline clusters. */
+declare function Flex<C extends ElementType = "div">(props: FlexProps<C>): react.JSX.Element;
+
+interface GridOwnProps {
+    /**
+     * Fixed column count, or `{ min: "220px" }` for the responsive
+     * auto-fit pattern (as many min-width columns as fit).
+     */
+    columns?: number | {
+        min: string;
+    };
+    gap?: StackGap;
+    className?: string;
+    style?: CSSProperties;
+}
+type GridProps<C extends ElementType = "div"> = PolymorphicProps<C, GridOwnProps>;
+/** CSS-grid helper: fixed columns or responsive auto-fit via `columns={{ min }}`. */
+declare function Grid<C extends ElementType = "div">(props: GridProps<C>): react.JSX.Element;
+
+interface ContainerOwnProps {
+    size?: "sm" | "md" | "lg" | "xl" | "full";
+    className?: string;
+}
+type ContainerProps<C extends ElementType = "div"> = PolymorphicProps<C, ContainerOwnProps>;
+/** Centered max-width page container with consistent side padding. */
+declare function Container<C extends ElementType = "div">(props: ContainerProps<C>): react.JSX.Element;
+
+interface PanelOwnProps {
+    padding?: "none" | "sm" | "md" | "lg";
+    elevation?: "flat" | "raised" | "overlay";
+    className?: string;
+}
+type PanelProps<C extends ElementType = "div"> = PolymorphicProps<C, PanelOwnProps>;
+/** Bordered surface card — the building block of sectioned pages. */
+declare function Panel<C extends ElementType = "div">(props: PanelProps<C>): react.JSX.Element;
+
+interface DividerProps extends ComponentPropsWithoutRef<"div"> {
+    orientation?: "horizontal" | "vertical";
+    /** Optional inline label rendered mid-line (horizontal only). */
+    label?: ReactNode;
+}
+/** Semantic separator; supports a centered label ("or", section names). */
+declare function Divider({ orientation, label, className, ...rest }: DividerProps): react.JSX.Element;
+
+interface PageHeaderProps extends Omit<HTMLAttributes<HTMLElement>, "title"> {
+    title: ReactNode;
+    description?: ReactNode;
+    actions?: ReactNode;
+    breadcrumbs?: ReactNode;
+}
+declare const PageHeader: react.ForwardRefExoticComponent<PageHeaderProps & react.RefAttributes<HTMLElement>>;
+
+interface TabItem<TKey extends string> {
+    key: TKey;
+    label: ReactNode;
+    icon?: ReactNode;
+    /** Count/status pill after the label. */
+    badge?: ReactNode;
+    disabled?: boolean;
+}
+interface TabsProps<TKey extends string> {
+    tabs: ReadonlyArray<TabItem<TKey>>;
+    /** Controlled active key. */
+    value?: TKey;
+    /** Uncontrolled initial key; defaults to the first enabled tab. */
+    defaultValue?: TKey;
+    onChange?: (key: TKey) => void;
+    "aria-label": string;
+    /**
+     * Panel content per tab. When omitted, Tabs renders only the tablist —
+     * for URL-driven tabs where the app owns what's below.
+     */
+    renderPanel?: (key: TKey) => ReactNode;
+    className?: string;
+}
+/**
+ * WAI-ARIA tabs: roving tabindex, Left/Right/Home/End keyboard activation,
+ * underline styling. Controlled (URL-driven) or uncontrolled.
+ */
+declare function Tabs<TKey extends string>({ tabs, value, defaultValue, onChange, renderPanel, className, ...rest }: TabsProps<TKey>): react.JSX.Element;
+
+interface BreadcrumbItem {
+    label: ReactNode;
+    /** Link target; the last item (current page) typically omits it. */
+    href?: string;
+}
+interface BreadcrumbsProps {
+    items: ReadonlyArray<BreadcrumbItem>;
+    /**
+     * Link component (e.g. your router's Link). Defaults to <a> — the
+     * framework never owns routing.
+     */
+    linkComponent?: ElementType;
+    separator?: ReactNode;
+    className?: string;
+}
+/** Breadcrumb trail with nav landmark + aria-current on the last item. */
+declare function Breadcrumbs({ items, linkComponent: LinkComponent, separator, className, }: BreadcrumbsProps): react.JSX.Element;
+
+interface PaginationProps {
+    /** Current 1-based page. */
+    page: number;
+    pageCount: number;
+    onPageChange: (page: number) => void;
+    /** Neighbor pages shown around the current page. @default 1 */
+    siblingCount?: number;
+    className?: string;
+}
+/**
+ * Page navigation with ellipsis collapsing (via util-library's pageRange),
+ * prev/next controls, and aria-current on the active page.
+ */
+declare function Pagination({ page, pageCount, onPageChange, siblingCount, className }: PaginationProps): react.JSX.Element | null;
+
+declare const DropdownMenu: react.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: react.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: react.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: react.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: react.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: react.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: react.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): react.JSX.Element;
+    displayName: string;
+};
+
+declare const Command: react.ForwardRefExoticComponent<Omit<{
+    children?: react.ReactNode;
+} & Pick<Pick<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof react.HTMLAttributes<HTMLDivElement>> & {
+    ref?: react.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+type CommandDialogProps = react.ComponentPropsWithoutRef<typeof Dialog>;
+declare const CommandDialog: ({ children, ...props }: CommandDialogProps) => react.JSX.Element;
+declare const CommandInput: react.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<react.DetailedHTMLProps<react.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof react.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: react.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof react.InputHTMLAttributes<HTMLInputElement>>, "value" | "onChange" | "type"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & react.RefAttributes<HTMLInputElement>, "ref"> & react.RefAttributes<HTMLInputElement>>;
+declare const CommandList: react.ForwardRefExoticComponent<Omit<{
+    children?: react.ReactNode;
+} & Pick<Pick<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof react.HTMLAttributes<HTMLDivElement>> & {
+    ref?: react.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+} & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: react.ForwardRefExoticComponent<Omit<{
+    children?: react.ReactNode;
+} & Pick<Pick<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof react.HTMLAttributes<HTMLDivElement>> & {
+    ref?: react.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: react.ForwardRefExoticComponent<Omit<{
+    children?: react.ReactNode;
+} & Omit<Pick<Pick<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof react.HTMLAttributes<HTMLDivElement>> & {
+    ref?: react.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild">, "value" | "heading"> & {
+    heading?: react.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: react.ForwardRefExoticComponent<Omit<Pick<Pick<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof react.HTMLAttributes<HTMLDivElement>> & {
+    ref?: react.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    alwaysRender?: boolean;
+} & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: react.ForwardRefExoticComponent<Omit<{
+    children?: react.ReactNode;
+} & Omit<Pick<Pick<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof react.HTMLAttributes<HTMLDivElement>> & {
+    ref?: react.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof react.HTMLAttributes<HTMLDivElement> | "asChild">, "value" | "disabled" | "onSelect"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: react.HTMLAttributes<HTMLSpanElement>): react.JSX.Element;
+    displayName: string;
+};
+
+declare const Accordion: react.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & react.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: react.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: react.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: react.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const Avatar: react.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & react.RefAttributes<HTMLSpanElement>, "ref"> & react.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: react.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & react.RefAttributes<HTMLImageElement>, "ref"> & react.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: react.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & react.RefAttributes<HTMLSpanElement>, "ref"> & react.RefAttributes<HTMLSpanElement>>;
+
+type BadgeVariant = "default" | "secondary" | "success" | "warning" | "danger" | "info" | "outline" | "primary-subtle" | "success-subtle" | "warning-subtle" | "danger-subtle" | "info-subtle";
+interface BadgeProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: BadgeVariant;
+    /** Renders a small circular dot indicator before the badge text. */
+    dot?: boolean;
+}
+declare const Badge: react.ForwardRefExoticComponent<BadgeProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const Card: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: react.ForwardRefExoticComponent<HTMLAttributes<HTMLHeadingElement> & react.RefAttributes<HTMLHeadingElement>>;
+declare const CardDescription: react.ForwardRefExoticComponent<HTMLAttributes<HTMLParagraphElement> & react.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+
+interface DataTableProps<TData, TValue> {
+    columns: ColumnDef<TData, TValue>[];
+    data: TData[];
+    className?: string;
+}
+declare function DataTable<TData, TValue>({ columns, data, className, }: DataTableProps<TData, TValue>): react.JSX.Element;
+
+interface TimelineProps extends react.HTMLAttributes<HTMLOListElement> {
+    children: react.ReactNode;
+}
+declare const Timeline: react.ForwardRefExoticComponent<TimelineProps & react.RefAttributes<HTMLOListElement>>;
+interface TimelineItemProps extends react.HTMLAttributes<HTMLLIElement> {
+    children: react.ReactNode;
+}
+declare const TimelineItem: react.ForwardRefExoticComponent<TimelineItemProps & react.RefAttributes<HTMLLIElement>>;
+interface TimelineDotProps extends react.HTMLAttributes<HTMLDivElement> {
+    intent?: "default" | "primary" | "success" | "warning" | "danger" | "info";
+}
+declare const TimelineDot: react.ForwardRefExoticComponent<TimelineDotProps & react.RefAttributes<HTMLDivElement>>;
+type TimelineContentProps = react.HTMLAttributes<HTMLDivElement>;
+declare const TimelineContent: react.ForwardRefExoticComponent<TimelineContentProps & react.RefAttributes<HTMLDivElement>>;
+type TimelineTimeProps = react.TimeHTMLAttributes<HTMLTimeElement>;
+declare const TimelineTime: react.ForwardRefExoticComponent<TimelineTimeProps & react.RefAttributes<HTMLTimeElement>>;
+type TimelineTitleProps = react.HTMLAttributes<HTMLHeadingElement>;
+declare const TimelineTitle: react.ForwardRefExoticComponent<TimelineTitleProps & react.RefAttributes<HTMLHeadingElement>>;
+type TimelineDescriptionProps = react.HTMLAttributes<HTMLParagraphElement>;
+declare const TimelineDescription: react.ForwardRefExoticComponent<TimelineDescriptionProps & react.RefAttributes<HTMLParagraphElement>>;
+
+interface StepItem {
+    label: react.ReactNode;
+    description?: react.ReactNode;
+}
+interface StepsProps extends react.HTMLAttributes<HTMLDivElement> {
+    steps: StepItem[];
+    activeStep?: number;
+}
+declare const Steps: react.ForwardRefExoticComponent<StepsProps & react.RefAttributes<HTMLDivElement>>;
+
+interface StatCardProps extends Omit<react.HTMLAttributes<HTMLDivElement>, "title"> {
+    title: react.ReactNode;
+    value: react.ReactNode;
+    trend?: {
+        value: string;
+        isPositive?: boolean;
+        label?: string;
+    };
+    icon?: react.ReactNode;
+}
+/**
+ * A dashboard KPI tile: label, prominent value, optional icon, and an
+ * optional trend indicator (arrow direction and color follow
+ * `trend.isPositive`; omit it for a neutral trend).
+ *
+ * @example
+ * <StatCard
+ *   title="Active patients"
+ *   value="128"
+ *   trend={{ value: "+12%", isPositive: true, label: "vs last month" }}
+ * />
+ */
+declare const StatCard: react.ForwardRefExoticComponent<StatCardProps & react.RefAttributes<HTMLDivElement>>;
+
+/** A single row of chart data: one index value plus one number per series. */
+type ChartDatum = Record<string, unknown>;
+/** Full configuration for one plotted series. */
+interface ChartSeries<TDatum extends ChartDatum = ChartDatum> {
+    /** Key in each datum holding this series' numeric value. */
+    dataKey: Extract<keyof TDatum, string>;
+    /** Human-readable name shown in the legend and tooltip. Defaults to `dataKey`. */
+    label?: string;
+    /**
+     * CSS color for the series. Defaults to the categorical chart palette
+     * (`--ml-chart-1` … `--ml-chart-8`, assigned in order).
+     */
+    color?: string;
+}
+/** A series may be given as a bare data key or a full {@link ChartSeries}. */
+type ChartSeriesInput<TDatum extends ChartDatum = ChartDatum> = Extract<keyof TDatum, string> | ChartSeries<TDatum>;
+/** Props shared by every cartesian chart (line, bar, area). */
+interface CartesianChartProps<TDatum extends ChartDatum = ChartDatum> extends Omit<react.HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Rows to plot. Each row holds the index value plus one number per series. */
+    data: readonly TDatum[];
+    /** Key in each datum used for the category (x) axis. */
+    index: Extract<keyof TDatum, string>;
+    /** Series to plot, in palette-assignment order. */
+    series: ReadonlyArray<ChartSeriesInput<TDatum>>;
+    /** Chart height (the width always fills the container). @default 300 */
+    height?: number | string;
+    /** Formats numeric values in the y-axis ticks and tooltip. */
+    valueFormatter?: (value: number) => string;
+    /** Formats category values in the x-axis ticks and tooltip header. */
+    indexFormatter?: (value: string | number) => string;
+    /** Render horizontal grid lines. @default true */
+    showGrid?: boolean;
+    /** Render the hover tooltip. @default true */
+    showTooltip?: boolean;
+    /** Render the legend. Defaults to `true` when more than one series is plotted. */
+    showLegend?: boolean;
+    /** Render the x axis. @default true */
+    showXAxis?: boolean;
+    /** Render the y axis. @default true */
+    showYAxis?: boolean;
+}
+
+/** Number of colors in the categorical chart palette (`--ml-chart-1..8`). */
+declare const CHART_PALETTE_SIZE = 8;
+/**
+ * The categorical palette color for a zero-based series position.
+ * Cycles when there are more series than palette entries.
+ */
+declare function chartColor(position: number): string;
+/**
+ * Normalizes the `series` prop (bare keys or full configs) into fully
+ * resolved series: label defaults to the data key, color to the palette.
+ */
+declare function resolveSeries<TDatum extends ChartDatum>(series: ReadonlyArray<ChartSeriesInput<TDatum>>): Array<Required<ChartSeries<TDatum>>>;
+
+/**
+ * The payload entries recharts injects into a custom tooltip's `content`
+ * element. Typed structurally so the framework's public API does not leak
+ * recharts internals.
+ */
+interface ChartTooltipPayloadEntry {
+    name?: string | number;
+    value?: number | string | ReadonlyArray<number | string>;
+    color?: string;
+    dataKey?: string | number;
+}
+interface ChartTooltipContentProps {
+    /** Injected by recharts: whether the tooltip is active. */
+    active?: boolean;
+    /** Injected by recharts: the hovered category value. */
+    label?: string | number;
+    /** Injected by recharts: one entry per series at the hovered index. */
+    payload?: ReadonlyArray<ChartTooltipPayloadEntry>;
+    /** Formats numeric series values. */
+    valueFormatter?: (value: number) => string;
+    /** Formats the category header. */
+    indexFormatter?: (value: string | number) => string;
+    className?: string;
+}
+/**
+ * Token-styled tooltip body shared by every chart. Renders the hovered
+ * category as a header and one swatch + label + value row per series.
+ */
+declare function ChartTooltipContent({ active, label, payload, valueFormatter, indexFormatter, className, }: ChartTooltipContentProps): react.JSX.Element | null;
+
+/** Structurally-typed legend entries injected by recharts. */
+interface ChartLegendPayloadEntry {
+    value?: string | number;
+    color?: string;
+    dataKey?: string | number;
+}
+interface ChartLegendContentProps {
+    /** Injected by recharts: one entry per series. */
+    payload?: ReadonlyArray<ChartLegendPayloadEntry>;
+    className?: string;
+}
+/** Token-styled horizontal legend shared by every chart. */
+declare function ChartLegendContent({ payload, className }: ChartLegendContentProps): react.JSX.Element | null;
+
+interface LineChartProps<TDatum extends ChartDatum = ChartDatum> extends CartesianChartProps<TDatum> {
+    /** Line interpolation. @default "monotone" */
+    curve?: "monotone" | "linear" | "step";
+    /** Render a dot at every data point (hover dots always render). @default false */
+    showDots?: boolean;
+}
+/**
+ * Multi-series line chart for trends over an ordered axis (time, sessions,
+ * visits). Colors come from the categorical chart tokens, so lines restyle
+ * with the theme automatically.
+ *
+ * @example
+ * <LineChart
+ *   data={sessions}
+ *   index="week"
+ *   series={["completed", "cancelled"]}
+ *   valueFormatter={(v) => `${v} sessions`}
+ *   aria-label="Completed and cancelled sessions per week"
+ * />
+ */
+declare function LineChart<TDatum extends ChartDatum>({ data, index, series, height, valueFormatter, indexFormatter, showGrid, showTooltip, showLegend, showXAxis, showYAxis, curve, showDots, ...rootProps }: LineChartProps<TDatum>): react.JSX.Element;
+
+interface BarChartProps<TDatum extends ChartDatum = ChartDatum> extends CartesianChartProps<TDatum> {
+    /** Stack the series instead of grouping them side by side. @default false */
+    stacked?: boolean;
+}
+/**
+ * Multi-series bar chart for categorical comparisons (visits per provider,
+ * claims per payer). Colors come from the categorical chart tokens, so bars
+ * restyle with the theme automatically.
+ *
+ * @example
+ * <BarChart
+ *   data={claims}
+ *   index="month"
+ *   series={[
+ *     { dataKey: "submitted", label: "Submitted" },
+ *     { dataKey: "denied", label: "Denied", color: "var(--ml-danger)" },
+ *   ]}
+ *   stacked
+ *   aria-label="Submitted and denied claims per month"
+ * />
+ */
+declare function BarChart<TDatum extends ChartDatum>({ data, index, series, height, valueFormatter, indexFormatter, showGrid, showTooltip, showLegend, showXAxis, showYAxis, stacked, ...rootProps }: BarChartProps<TDatum>): react.JSX.Element;
+
+interface AreaChartProps<TDatum extends ChartDatum = ChartDatum> extends CartesianChartProps<TDatum> {
+    /** Line interpolation. @default "monotone" */
+    curve?: "monotone" | "linear" | "step";
+    /** Stack the series to show part-to-whole composition. @default false */
+    stacked?: boolean;
+}
+/**
+ * Multi-series area chart for cumulative trends and part-to-whole
+ * composition over time (caseload by program, utilization by location).
+ * Colors come from the categorical chart tokens, so fills restyle with the
+ * theme automatically.
+ *
+ * @example
+ * <AreaChart
+ *   data={caseload}
+ *   index="month"
+ *   series={["aba", "speech", "ot"]}
+ *   stacked
+ *   aria-label="Monthly caseload by service line"
+ * />
+ */
+declare function AreaChart<TDatum extends ChartDatum>({ data, index, series, height, valueFormatter, indexFormatter, showGrid, showTooltip, showLegend, showXAxis, showYAxis, curve, stacked, ...rootProps }: AreaChartProps<TDatum>): react.JSX.Element;
+
+/**
+ * @cocliny/ui-library
+ *
+ * Presentation-only React components over a token-driven design system.
+ *
+ * Rules for everything added here:
+ * - Components receive data via props, render it, and emit callbacks.
+ * - No data fetching, no business logic, no application state.
+ * - Every component exposes className / style / slot overrides / render hooks.
+ * - All styling consumes design tokens (CSS variables) — never hardcoded values.
+ * - WCAG AA: keyboard navigation, focus management, ARIA, reduced motion.
+ */
+
+/** Framework version marker. Replaced by the release pipeline. */
+declare const UI_LIBRARY_VERSION: "0.0.0";
+
+export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Alert, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, type AlertIntent, type AlertProps, AreaChart, type AreaChartProps, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, type BadgeVariant, BarChart, type BarChartProps, type BreadcrumbItem, Breadcrumbs, type BreadcrumbsProps, Button, ButtonGroup, type ButtonGroupProps, type ButtonIntent, type ButtonProps, type ButtonSize, type ButtonVariant, CHART_PALETTE_SIZE, Calendar, type CalendarProps, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, type CartesianChartProps, type ChartDatum, ChartLegendContent, type ChartLegendContentProps, type ChartLegendPayloadEntry, type ChartSeries, type ChartSeriesInput, ChartTooltipContent, type ChartTooltipContentProps, type ChartTooltipPayloadEntry, Checkbox, type CheckboxProps, Code, CodeInput, type CodeInputProps, type CodeProps, type ColorScheme, Combobox, type ComboboxOption, type ComboboxProps, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, type CommonProps, Container, type ContainerOwnProps, type ContainerProps, DataTable, type DataTableProps, DatePicker, type DatePickerProps, DateRangePicker, type DateRangePickerProps, type Density, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, Divider, type DividerProps, Drawer, DrawerClose, DrawerContent, type DrawerContentProps, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EmptyState, type EmptyStateProps, ErrorState, Field, type FieldContextValue, type FieldProps, FileUpload, type FileUploadProps, Flex, type FlexOwnProps, type FlexProps, Form, FormControl, FormDescription, FormField, FormItem, FormLabel, FormMessage, Grid, type GridOwnProps, type GridProps, Heading, type HeadingLevel, type HeadingOwnProps, type HeadingProps, type HeadingSize, IconButton, type IconButtonProps, type Intent, Label, type LabelProps, LineChart, type LineChartProps, Link, type LinkOwnProps, type LinkProps, LoadingOverlay, type LoadingOverlayProps, MultiSelect, type MultiSelectOption, type MultiSelectProps, PageHeader, type PageHeaderProps, Pagination, type PaginationProps, Panel, type PanelOwnProps, type PanelProps, PasswordInput, type PasswordInputProps, type PolymorphicProps, type PolymorphicPropsWithRef, type PolymorphicRef, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, Progress, type ProgressProps, RadioGroup, type RadioGroupProps, type RadioOption, type Radius, type RenderHook, type ResolvedColorScheme, SearchInput, type SearchInputProps, Select, type SelectOption, type SelectProps, SignatureInput, type SignatureInputProps, type Size, Skeleton, type SkeletonProps, Slider, type SliderProps, type SlotClassNames, type SlotStyles, type SlottableProps, Spinner, type SpinnerProps, Stack, type StackAlign, type StackGap, type StackOwnProps, type StackProps, StatCard, type StatCardProps, StatusIndicator, type StatusIndicatorProps, type StepItem, Steps, type StepsProps, SuccessState, Switch, type SwitchProps, TOKEN_CSS_VARS, type TabItem, Tabs, type TabsProps, Text, type TextAlign, TextInput, type TextInputProps, type TextOwnProps, type TextProps, type TextSize, type TextTone, type TextWeight, Textarea, type TextareaProps, type ThemeContextValue, type ThemeOverrides, ThemeProvider, type ThemeProviderProps, type ThemeToken, Timeline, TimelineContent, type TimelineContentProps, TimelineDescription, type TimelineDescriptionProps, TimelineDot, type TimelineDotProps, TimelineItem, type TimelineItemProps, type TimelineProps, TimelineTime, type TimelineTimeProps, TimelineTitle, type TimelineTitleProps, Toast, ToastAction, ToastClose, ToastDescription, ToastProvider, ToastTitle, ToastViewport, ToggleGroup, ToggleGroupItem, type TokenValues, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, UI_LIBRARY_VERSION, type VariantFn, type VariantProps, type VariantsConfig, chartColor, cn, defineVariants, getThemeInitScript, inputClassName, resolveSeries, themeOverridesToCss, useFieldContext, useFieldInputProps, useFormField, useTheme };