@kismet-ux/constellation 1.0.0

package/dist/hooks/use-mobile.d.ts

@@ -0,0 +1,6 @@
+export declare function useBreakpoint(): {
+    width: number | undefined;
+    isBelow: (value?: number) => boolean;
+};
+export declare function useIsMobile(breakpoint?: number): boolean;
+//# sourceMappingURL=use-mobile.d.ts.map

package/dist/hooks/use-mobile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-mobile.d.ts","sourceRoot":"","sources":["../../src/hooks/use-mobile.tsx"],"names":[],"mappings":"AAgEA,wBAAgB,aAAa;;sBAUjB,MAAM;EAKjB;AAED,wBAAgB,WAAW,CAAC,UAAU,GAAE,MAA0B,WAGjE"}

package/dist/hooks/use-mobile.js

@@ -0,0 +1,73 @@
+import { useState, useEffect, useCallback } from 'react';
+
+const MOBILE_BREAKPOINT = 768;
+let currentWidth = typeof window === 'undefined' ? undefined : window.innerWidth;
+const listeners = new Set();
+let resizeHandler = null;
+let resizeRaf = 0;
+function ensureResizeListener() {
+    if (typeof window === 'undefined' || resizeHandler)
+        return;
+    const notify = (width) => {
+        if (width === currentWidth)
+            return;
+        currentWidth = width;
+        listeners.forEach(listener => listener(width));
+    };
+    const readWidth = () => window.innerWidth;
+    const onResize = () => {
+        if (resizeRaf)
+            cancelAnimationFrame(resizeRaf);
+        resizeRaf = requestAnimationFrame(() => {
+            resizeRaf = 0;
+            notify(readWidth());
+        });
+    };
+    resizeHandler = onResize;
+    window.addEventListener('resize', onResize, { passive: true });
+    // Prime current width
+    notify(readWidth());
+}
+function teardownResizeListener() {
+    if (!resizeHandler)
+        return;
+    window.removeEventListener('resize', resizeHandler);
+    resizeHandler = null;
+    if (resizeRaf) {
+        cancelAnimationFrame(resizeRaf);
+        resizeRaf = 0;
+    }
+}
+function subscribeWidth(listener) {
+    listeners.add(listener);
+    if (currentWidth !== undefined) {
+        listener(currentWidth);
+    }
+    if (listeners.size === 1) {
+        ensureResizeListener();
+    }
+}
+function unsubscribeWidth(listener) {
+    listeners.delete(listener);
+    if (listeners.size === 0) {
+        teardownResizeListener();
+    }
+}
+function useBreakpoint() {
+    const [width, setWidth] = useState(currentWidth);
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        subscribeWidth(setWidth);
+        return () => unsubscribeWidth(setWidth);
+    }, []);
+    const isBelow = useCallback((value = MOBILE_BREAKPOINT) => (width ?? Number.MAX_SAFE_INTEGER) < value, [width]);
+    return { width, isBelow };
+}
+function useIsMobile(breakpoint = MOBILE_BREAKPOINT) {
+    const { isBelow } = useBreakpoint();
+    return isBelow(breakpoint);
+}
+
+export { useBreakpoint, useIsMobile };
+//# sourceMappingURL=use-mobile.js.map

package/dist/hooks/use-mobile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-mobile.js","sources":["../../src/hooks/use-mobile.tsx"],"sourcesContent":["import { useCallback, useEffect, useState } from 'react';\n\nconst MOBILE_BREAKPOINT = 768;\n\ntype WidthListener = (width: number) => void;\n\nlet currentWidth = typeof window === 'undefined' ? undefined : window.innerWidth;\nconst listeners = new Set<WidthListener>();\nlet resizeHandler: (() => void) | null = null;\nlet resizeRaf = 0;\n\nfunction ensureResizeListener() {\n  if (typeof window === 'undefined' || resizeHandler) return;\n\n  const notify = (width: number) => {\n    if (width === currentWidth) return;\n    currentWidth = width;\n    listeners.forEach(listener => listener(width));\n  };\n\n  const readWidth = () => window.innerWidth;\n\n  const onResize = () => {\n    if (resizeRaf) cancelAnimationFrame(resizeRaf);\n    resizeRaf = requestAnimationFrame(() => {\n      resizeRaf = 0;\n      notify(readWidth());\n    });\n  };\n\n  resizeHandler = onResize;\n  window.addEventListener('resize', onResize, { passive: true });\n\n  // Prime current width\n  notify(readWidth());\n}\n\nfunction teardownResizeListener() {\n  if (!resizeHandler) return;\n  window.removeEventListener('resize', resizeHandler);\n  resizeHandler = null;\n  if (resizeRaf) {\n    cancelAnimationFrame(resizeRaf);\n    resizeRaf = 0;\n  }\n}\n\nfunction subscribeWidth(listener: WidthListener) {\n  listeners.add(listener);\n  if (currentWidth !== undefined) {\n    listener(currentWidth);\n  }\n  if (listeners.size === 1) {\n    ensureResizeListener();\n  }\n}\n\nfunction unsubscribeWidth(listener: WidthListener) {\n  listeners.delete(listener);\n  if (listeners.size === 0) {\n    teardownResizeListener();\n  }\n}\n\nexport function useBreakpoint() {\n  const [width, setWidth] = useState<number | undefined>(currentWidth);\n\n  useEffect(() => {\n    if (typeof window === 'undefined') return;\n    subscribeWidth(setWidth);\n    return () => unsubscribeWidth(setWidth);\n  }, []);\n\n  const isBelow = useCallback(\n    (value: number = MOBILE_BREAKPOINT) => (width ?? Number.MAX_SAFE_INTEGER) < value,\n    [width],\n  );\n\n  return { width, isBelow };\n}\n\nexport function useIsMobile(breakpoint: number = MOBILE_BREAKPOINT) {\n  const { isBelow } = useBreakpoint();\n  return isBelow(breakpoint);\n}\n"],"names":[],"mappings":";;AAEA,MAAM,iBAAiB,GAAG,GAAG;AAI7B,IAAI,YAAY,GAAG,OAAO,MAAM,KAAK,WAAW,GAAG,SAAS,GAAG,MAAM,CAAC,UAAU;AAChF,MAAM,SAAS,GAAG,IAAI,GAAG,EAAiB;AAC1C,IAAI,aAAa,GAAwB,IAAI;AAC7C,IAAI,SAAS,GAAG,CAAC;AAEjB,SAAS,oBAAoB,GAAA;AAC3B,IAAA,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,aAAa;QAAE;AAEpD,IAAA,MAAM,MAAM,GAAG,CAAC,KAAa,KAAI;QAC/B,IAAI,KAAK,KAAK,YAAY;YAAE;QAC5B,YAAY,GAAG,KAAK;AACpB,QAAA,SAAS,CAAC,OAAO,CAAC,QAAQ,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC;AAChD,IAAA,CAAC;IAED,MAAM,SAAS,GAAG,MAAM,MAAM,CAAC,UAAU;IAEzC,MAAM,QAAQ,GAAG,MAAK;AACpB,QAAA,IAAI,SAAS;YAAE,oBAAoB,CAAC,SAAS,CAAC;AAC9C,QAAA,SAAS,GAAG,qBAAqB,CAAC,MAAK;YACrC,SAAS,GAAG,CAAC;AACb,YAAA,MAAM,CAAC,SAAS,EAAE,CAAC;AACrB,QAAA,CAAC,CAAC;AACJ,IAAA,CAAC;IAED,aAAa,GAAG,QAAQ;AACxB,IAAA,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;;AAG9D,IAAA,MAAM,CAAC,SAAS,EAAE,CAAC;AACrB;AAEA,SAAS,sBAAsB,GAAA;AAC7B,IAAA,IAAI,CAAC,aAAa;QAAE;AACpB,IAAA,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,aAAa,CAAC;IACnD,aAAa,GAAG,IAAI;IACpB,IAAI,SAAS,EAAE;QACb,oBAAoB,CAAC,SAAS,CAAC;QAC/B,SAAS,GAAG,CAAC;IACf;AACF;AAEA,SAAS,cAAc,CAAC,QAAuB,EAAA;AAC7C,IAAA,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC;AACvB,IAAA,IAAI,YAAY,KAAK,SAAS,EAAE;QAC9B,QAAQ,CAAC,YAAY,CAAC;IACxB;AACA,IAAA,IAAI,SAAS,CAAC,IAAI,KAAK,CAAC,EAAE;AACxB,QAAA,oBAAoB,EAAE;IACxB;AACF;AAEA,SAAS,gBAAgB,CAAC,QAAuB,EAAA;AAC/C,IAAA,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC;AAC1B,IAAA,IAAI,SAAS,CAAC,IAAI,KAAK,CAAC,EAAE;AACxB,QAAA,sBAAsB,EAAE;IAC1B;AACF;SAEgB,aAAa,GAAA;IAC3B,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAqB,YAAY,CAAC;IAEpE,SAAS,CAAC,MAAK;QACb,IAAI,OAAO,MAAM,KAAK,WAAW;YAAE;QACnC,cAAc,CAAC,QAAQ,CAAC;AACxB,QAAA,OAAO,MAAM,gBAAgB,CAAC,QAAQ,CAAC;IACzC,CAAC,EAAE,EAAE,CAAC;IAEN,MAAM,OAAO,GAAG,WAAW,CACzB,CAAC,QAAgB,iBAAiB,KAAK,CAAC,KAAK,IAAI,MAAM,CAAC,gBAAgB,IAAI,KAAK,EACjF,CAAC,KAAK,CAAC,CACR;AAED,IAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE;AAC3B;AAEM,SAAU,WAAW,CAAC,UAAA,GAAqB,iBAAiB,EAAA;AAChE,IAAA,MAAM,EAAE,OAAO,EAAE,GAAG,aAAa,EAAE;AACnC,IAAA,OAAO,OAAO,CAAC,UAAU,CAAC;AAC5B;;"}

package/dist/index-Bzf20Rpc.d.ts

@@ -0,0 +1,120 @@
+import * as React from 'react';
+import React__default from 'react';
+import './input-CWHXOpeH.js';
+import { VariantProps } from 'class-variance-authority';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+
+type DatePickerProps = {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    label?: React__default.ReactNode;
+    helperText?: React__default.ReactNode;
+    error?: boolean;
+    disabled?: boolean;
+    sizeVariant?: 'sm' | 'md';
+    placeholder?: string;
+    min?: string;
+    max?: string;
+    required?: boolean;
+    id?: string;
+    className?: string;
+    name?: string;
+};
+
+type SelectAlign = 'start' | 'center' | 'end';
+type SelectSide = 'top' | 'bottom' | 'left' | 'right';
+type SelectPosition = 'item-aligned' | 'popper';
+type SelectProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    children?: React__default.ReactNode;
+};
+type SelectContentProps = React__default.HTMLAttributes<HTMLDivElement> & {
+    position?: SelectPosition;
+    align?: SelectAlign;
+    side?: SelectSide;
+    sideOffset?: number;
+    collisionPadding?: number;
+};
+type SelectFieldContentProps = Pick<SelectContentProps, 'align' | 'className' | 'collisionPadding' | 'side' | 'sideOffset'>;
+type SelectFieldBaseProps = Omit<SelectProps, 'value' | 'defaultValue' | 'onValueChange'> & {
+    'aria-required'?: boolean;
+    label?: React__default.ReactNode;
+    helperText?: React__default.ReactNode;
+    error?: boolean;
+    placeholder?: string;
+    fieldClassName?: string;
+    contentProps?: SelectFieldContentProps;
+    id?: string;
+    children?: React__default.ReactNode;
+    sizeVariant?: 'sm' | 'md';
+    searchThreshold?: number;
+};
+type SingleSelectFieldProps = SelectFieldBaseProps & {
+    multiple?: false;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+};
+type MultiSelectFieldProps = SelectFieldBaseProps & {
+    multiple: true;
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+};
+type SelectFieldProps = SingleSelectFieldProps | MultiSelectFieldProps;
+
+type FormTheme = 'inherit' | 'primary' | 'secondary' | 'destructive' | 'warning' | 'success' | 'info' | 'slate';
+
+type CheckedState = boolean | 'indeterminate';
+interface CheckboxProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'value' | 'defaultValue' | 'defaultChecked'> {
+    theme?: FormTheme;
+    destructive?: boolean;
+    checked?: CheckedState;
+    defaultChecked?: CheckedState;
+    onCheckedChange?: (checked: CheckedState) => void;
+    value?: string;
+    name?: string;
+    required?: boolean;
+    /** Optional inline label rendered to the right of the checkbox and associated via htmlFor. */
+    label?: React.ReactNode;
+    /** Optional helper / validation text rendered beneath the checkbox + label row. */
+    helperText?: React.ReactNode;
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+
+declare function DatePicker({ value: valueProp, defaultValue, onChange, label, helperText, error, disabled, sizeVariant, placeholder, min, max, required, id, className, name, }: DatePickerProps): React.JSX.Element;
+
+declare const labelVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    theme?: "primary" | "secondary" | "destructive" | "success" | "warning" | "info" | "slate" | "inherit" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface LabelProps extends React.LabelHTMLAttributes<HTMLLabelElement>, VariantProps<typeof labelVariants> {
+    theme?: FormTheme;
+}
+declare const Label: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLLabelElement>>;
+
+declare function Select({ open: openProp, defaultOpen, onOpenChange, value: valueProp, defaultValue, onValueChange, disabled, children, ...props }: SelectProps): React.JSX.Element;
+declare function SelectGroup({ ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+declare function SelectValue({ children, placeholder, ...props }: React.HTMLAttributes<HTMLSpanElement> & {
+    placeholder?: React.ReactNode;
+}): React.JSX.Element;
+declare function SelectTrigger({ className, children, onClick, onKeyDown, type, ...props }: React.ButtonHTMLAttributes<HTMLButtonElement>): React.JSX.Element;
+declare function SelectContent({ align, className, children, collisionPadding, onKeyDown, position, side, sideOffset, ...props }: SelectContentProps): React.JSX.Element;
+declare function SelectItem({ className, children, disabled, onClick, onMouseMove, value, ...props }: React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    value: string;
+}): React.JSX.Element;
+declare function SelectSeparator({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+declare function SelectField(props: SelectFieldProps): React.JSX.Element;
+
+export { Checkbox as C, DatePicker as D, Label as L, Select as S, SelectContent as e, SelectField as g, SelectGroup as i, SelectItem as j, SelectSeparator as m, SelectTrigger as o, SelectValue as p };
+export type { FormTheme as F, CheckboxProps as a, DatePickerProps as b, LabelProps as c, SelectAlign as d, SelectContentProps as f, SelectFieldProps as h, SelectPosition as k, SelectProps as l, SelectSide as n };

package/dist/index-DECPicJT.d.ts

@@ -0,0 +1,450 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+import React__default, { ReactNode } from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import './tooltip-XagXjWLB.js';
+import { e as TypographyVariant } from './typography-DOZHFR5A.js';
+
+type AlertTheme = 'default' | 'primary' | 'secondary' | 'success' | 'destructive' | 'warning' | 'info' | 'slate';
+type AlertMessage = {
+    id: string;
+    title: string;
+    description?: string;
+    theme: AlertTheme;
+    timeout?: number;
+    persistent?: boolean;
+    closable?: boolean;
+};
+type PushAlertInput = Omit<AlertMessage, 'id'> & {
+    icon?: ReactNode;
+    action?: ReactNode;
+};
+type AlertContextValue = {
+    pushAlert: (alert: PushAlertInput) => void;
+    removeAlert: (id: string) => void;
+};
+
+type PaginationProps = {
+    page: number;
+    pageSize: number;
+    totalItems: number;
+    onPageChange: (page: number) => void;
+    onPageSizeChange: (size: number) => void;
+    pageSizeOptions?: number[];
+    className?: string;
+};
+
+type SortDirection = 'asc' | 'desc';
+type SortState = {
+    key: string;
+    direction: SortDirection;
+};
+type SortContextValue = {
+    sortState: SortState | null;
+    setSortState: React__default.Dispatch<React__default.SetStateAction<SortState | null>>;
+};
+
+declare const alertVariants: (props?: ({
+    theme?: "default" | "primary" | "secondary" | "destructive" | "success" | "warning" | "info" | "slate" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface AlertProps extends VariantProps<typeof alertVariants> {
+    className?: string;
+    icon?: React.ReactNode;
+    action?: React.ReactNode;
+    onClose?: () => void;
+    children?: React.ReactNode;
+}
+declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+declare function AlertTitle({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+declare function AlertDescription({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+interface AlertBannerProps extends VariantProps<typeof alertVariants> {
+    open: boolean;
+    onClose?: () => void;
+    icon?: boolean | React.ReactNode;
+    action?: React.ReactNode;
+    className?: string;
+    children?: React.ReactNode;
+}
+declare const AlertBanner: React.ForwardRefExoticComponent<AlertBannerProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const persistAlert: (alert: Omit<AlertMessage, "id">) => void;
+
+declare function AlertProvider({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+
+type AvatarProps = React.HTMLAttributes<HTMLSpanElement>;
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
+type AvatarImageProps = React.ImgHTMLAttributes<HTMLImageElement>;
+declare const AvatarImage: React.ForwardRefExoticComponent<AvatarImageProps & React.RefAttributes<HTMLImageElement>>;
+type AvatarFallbackProps = React.HTMLAttributes<HTMLSpanElement>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>>;
+
+declare const chipVariants: (props?: ({
+    theme?: "primary" | "secondary" | "destructive" | "success" | "warning" | "info" | "slate" | "inherit" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+    wrap?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface ChipProps extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof chipVariants> {
+}
+declare const Chip: React.ForwardRefExoticComponent<ChipProps & React.RefAttributes<HTMLSpanElement>>;
+
+declare const codeBlockVariants: (props?: ({
+    theme?: "default" | "primary" | "secondary" | "destructive" | "success" | "warning" | "info" | "slate" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface CodeBlockProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>, VariantProps<typeof codeBlockVariants> {
+    /** The code content to display. */
+    children: string;
+    /** Language label displayed in the header (e.g. "sql", "json", "typescript"). */
+    language?: string;
+    /** Show a copy-to-clipboard button. */
+    copyable?: boolean;
+    /** Enable collapse/expand behavior. When true, content is initially collapsed. */
+    collapsible?: boolean;
+    /** Max height in rem when collapsed. Defaults to 12. */
+    collapsedHeight?: number;
+    /** Whether the code block starts expanded when `collapsible` is true. */
+    defaultExpanded?: boolean;
+}
+declare const CodeBlock: React.ForwardRefExoticComponent<CodeBlockProps & React.RefAttributes<HTMLDivElement>>;
+
+interface DevIndicatorProps {
+    className?: string;
+}
+declare function DevIndicator({ className }: DevIndicatorProps): React.JSX.Element | null;
+
+interface DialogProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onAfterClose?: () => void;
+    children?: React.ReactNode;
+}
+declare function Dialog({ open: controlledOpen, defaultOpen, onOpenChange, onAfterClose, children, }: DialogProps): React.JSX.Element;
+interface DialogTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare function DialogTrigger({ asChild, onClick, children, ...props }: DialogTriggerProps): React.JSX.Element;
+interface DialogCloseProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare function DialogClose({ asChild, onClick, children, ...props }: DialogCloseProps): React.JSX.Element;
+declare function DialogOverlay({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+type DialogContentProps = React.HTMLAttributes<HTMLDivElement> & {
+    width?: 'max' | 'min';
+};
+declare function DialogContent({ className, children, width, ...props }: DialogContentProps): React.ReactPortal | null;
+declare function DialogHeader({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+declare function DialogFooter({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+/**
+ * Renders the dialog's heading. Defaults to `<Typography variant='h6'>`
+ * so consumers can write `<DialogTitle>My dialog</DialogTitle>` without
+ * manually wrapping in Typography. Override the variant with the
+ * `variant` prop, or opt out entirely with `asChild` to supply a custom
+ * element (e.g., a Heading component).
+ */
+declare function DialogTitle({ className, asChild, variant, ...props }: React.ComponentProps<'h2'> & {
+    asChild?: boolean;
+    variant?: TypographyVariant;
+}): React.JSX.Element;
+/**
+ * Renders the dialog's supporting description text. Defaults to
+ * `<Typography variant='body2'>`. Override with `variant` or supply a
+ * custom element via `asChild`.
+ */
+declare function DialogDescription({ className, asChild, variant, ...props }: React.ComponentProps<'p'> & {
+    asChild?: boolean;
+    variant?: TypographyVariant;
+}): React.JSX.Element;
+declare function DialogPortal({ children }: {
+    children?: React.ReactNode;
+}): React.JSX.Element;
+
+declare const emptyStateVariants: (props?: ({
+    theme?: "default" | "primary" | "secondary" | "destructive" | "success" | "warning" | "info" | "slate" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface EmptyStateProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof emptyStateVariants> {
+    /** Icon displayed above the title. */
+    icon?: React.ReactNode;
+    /** Primary heading text. */
+    title: string;
+    /** Secondary descriptive text below the title. */
+    description?: string;
+    /** Action element (typically a Button) rendered below the text. */
+    action?: React.ReactNode;
+}
+declare const EmptyState: React.ForwardRefExoticComponent<EmptyStateProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const iconVariants: (props?: ({
+    variant?: "contained" | "outlined" | "ghost" | "plain" | null | undefined;
+    theme?: "primary" | "secondary" | "destructive" | "success" | "warning" | "info" | "slate" | "inherit" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | null | undefined;
+    rounded?: boolean | "extra" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+type IconVariantSize = NonNullable<VariantProps<typeof iconVariants>['size']>;
+type IconNodeProps = React.SVGProps<SVGSVGElement> & {
+    size?: string | number;
+};
+interface IconProps extends React.HTMLAttributes<HTMLSpanElement>, Omit<VariantProps<typeof iconVariants>, 'size'> {
+    iconNode: React.ComponentType<IconNodeProps>;
+    size?: IconVariantSize | number;
+    /** Apply 1s linear infinite rotation to the inner SVG; also defaults role='status' for a11y. */
+    spin?: boolean;
+}
+/**
+ * Standalone icon with a sized wrapper box (e.g. status indicators, list-item
+ * leaders, themed avatars). Renders `<span><svg/></span>` — the span carries
+ * the `iconVariants` background/border for contained/outlined variants and a
+ * fixed pixel box per `size`.
+ *
+ * **DO NOT** place inside `Button`, `Chip`, `DropdownMenuItem`, or other host
+ * components that already size their SVG children via `:has(> svg)`. The host's
+ * size + padding adjustments only trigger for a direct-child `<svg>`, and
+ * Icon's wrapper span breaks that rule — you end up with the host's default
+ * (wider) padding plus Icon's full-height box (e.g. 1.85rem for `size='sm'`).
+ *
+ * Inside a host that sizes its own svg, pass the raw lucide component directly:
+ *
+ * ```tsx
+ * <Button>
+ *   <CheckIcon />
+ *   Save
+ * </Button>
+ *
+ * <Button>
+ *   <Loader2Icon className={'animate-spin'} />
+ *   Saving…
+ * </Button>
+ * ```
+ *
+ * Use `Icon` only when the wrapper box is desired (standalone use).
+ */
+declare const Icon: React.ForwardRefExoticComponent<IconProps & React.RefAttributes<HTMLSpanElement>>;
+
+interface ListProps extends React.HTMLAttributes<HTMLUListElement | HTMLOListElement> {
+    variant?: 'disc' | 'decimal' | 'none';
+    gap?: number;
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    muted?: boolean;
+}
+declare const List: React.ForwardRefExoticComponent<ListProps & React.RefAttributes<HTMLUListElement | HTMLOListElement>>;
+interface ListItemProps extends React.LiHTMLAttributes<HTMLLIElement> {
+    icon?: React.ReactNode;
+}
+declare const ListItem: React.ForwardRefExoticComponent<ListItemProps & React.RefAttributes<HTMLLIElement>>;
+
+declare const Pagination: React.ForwardRefExoticComponent<PaginationProps & React.RefAttributes<HTMLElement>>;
+
+declare const progressBarVariants: (props?: ({
+    theme?: "primary" | "secondary" | "destructive" | "success" | "warning" | "info" | "slate" | "inherit" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | null | undefined;
+    rounded?: boolean | null | undefined;
+    animated?: boolean | null | undefined;
+    indeterminate?: boolean | null | undefined;
+    striped?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface ProgressBarProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>, VariantProps<typeof progressBarVariants> {
+    /** Current progress value (0–100). Ignored when `indeterminate` is true. */
+    value?: number;
+    /** Accessible label describing what the progress bar represents. */
+    label?: string;
+}
+declare const ProgressBar: React.ForwardRefExoticComponent<ProgressBarProps & React.RefAttributes<HTMLDivElement>>;
+
+interface SeparatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    orientation?: 'horizontal' | 'vertical';
+    decorative?: boolean;
+}
+declare const Separator: React.ForwardRefExoticComponent<SeparatorProps & React.RefAttributes<HTMLDivElement>>;
+
+type TrendDirection = 'up' | 'down' | 'neutral';
+type StatCardTheme = 'default' | 'primary' | 'secondary' | 'destructive' | 'warning' | 'success' | 'info' | 'slate';
+type StatCardSize = 'sm' | 'md' | 'lg';
+type StatCardVariant = 'unstyled' | 'outlined' | 'filled';
+type StatCardDirection = 'row' | 'column';
+interface StatCardProps extends React.ComponentPropsWithoutRef<'div'> {
+    /** Text label describing the metric. */
+    label: string;
+    /** The metric value to display. */
+    value?: React.ReactNode;
+    /** Icon displayed beside the metric. */
+    icon?: React.ReactNode;
+    /** Optional description below the value. */
+    description?: string;
+    /** Trend direction indicator. */
+    trend?: TrendDirection;
+    /** Trend label text (e.g. "+12%", "−3.4%"). */
+    trendLabel?: string;
+    /** Visual theme for the card. */
+    theme?: StatCardTheme;
+    /** Card size. */
+    size?: StatCardSize;
+    /** Card Direction. */
+    direction?: StatCardDirection;
+    /** Surface variant. */
+    variant?: StatCardVariant;
+}
+declare const StatCard: React.ForwardRefExoticComponent<StatCardProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const stepProgressVariants: (props?: ({
+    theme?: "primary" | "secondary" | "destructive" | "success" | "warning" | "info" | "slate" | "inherit" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    orientation?: "horizontal" | "vertical" | null | undefined;
+    stretch?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface Step {
+    /** Label displayed next to or below the step indicator. */
+    label: string;
+    /** Optional secondary description below the label. */
+    description?: string;
+    /** Optional icon rendered inside the dot. Defaults to a checkmark for completed steps. */
+    icon?: React.ReactNode;
+}
+interface StepProgressProps extends Omit<React.HTMLAttributes<HTMLOListElement>, 'children'>, VariantProps<typeof stepProgressVariants> {
+    /** Array of step definitions. */
+    steps: Step[];
+    /** Zero-based index of the currently active step. Steps before this are complete. */
+    currentStep: number;
+}
+declare const StepProgress: React.ForwardRefExoticComponent<StepProgressProps & React.RefAttributes<HTMLOListElement>>;
+
+declare const switchVariants: (props?: ({
+    theme?: "primary" | "secondary" | "destructive" | "success" | "warning" | "info" | "slate" | "inherit" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface SwitchProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'onClick'>, VariantProps<typeof switchVariants> {
+    pressed?: boolean;
+    onPressedChange?: (pressed: boolean) => void;
+}
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+
+declare const TableCard: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Table: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLTableElement> & React.TableHTMLAttributes<HTMLTableElement> & {
+    defaultSort?: SortState;
+}, "ref"> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & React.RefAttributes<HTMLTableSectionElement>>;
+interface TableBodyProps extends React.ComponentProps<'tbody'> {
+    showEmptyState?: boolean;
+    emptyState?: React.ReactNode;
+    emptyStateColSpan?: number;
+}
+declare const TableBody: React.ForwardRefExoticComponent<Omit<TableBodyProps, "ref"> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, "ref"> & React.RefAttributes<HTMLTableRowElement>>;
+type TableHeaderProps = React.ComponentProps<'th'> & {
+    action?: 'sticky';
+};
+declare const TableHeader: React.ForwardRefExoticComponent<Omit<TableHeaderProps, "ref"> & React.RefAttributes<HTMLTableCellElement>>;
+type TableCellProps = React.ComponentProps<'td'> & {
+    action?: 'sticky';
+};
+declare const TableCell: React.ForwardRefExoticComponent<Omit<TableCellProps, "ref"> & React.RefAttributes<HTMLTableCellElement>>;
+interface TableSortableHeaderProps<Key extends string = string> {
+    label: string;
+    sortKey: Key;
+    defaultSort?: true | SortDirection;
+    action?: 'sticky';
+}
+declare function TableSortableHeader<Key extends string = string>({ label, sortKey, defaultSort, action, }: TableSortableHeaderProps<Key>): React.JSX.Element;
+
+interface TableActionItem {
+    /** Visible label for the action. */
+    label: string;
+    /** Optional icon rendered before the label. */
+    icon?: React.ReactNode;
+    /** Click handler for this action. */
+    onClick?: () => void;
+    /** Whether the action is disabled. */
+    disabled?: boolean;
+    /** Visual variant — `destructive` renders the item in the destructive theme. */
+    variant?: 'default' | 'destructive';
+}
+interface TableActionCellProps extends React.ComponentProps<'div'> {
+    /** Array of actions to display. Renders a single button for one action, or a dropdown for multiple. */
+    actions: TableActionItem[];
+    /** Accessible label for the dropdown trigger button. */
+    dropdownLabel?: string;
+}
+/**
+ * Renders a right-aligned action cell for table rows.
+ *
+ * - **Single action**: renders a visible `<Button>` with the action label and optional icon.
+ * - **Multiple actions**: renders a `...` icon button that opens a `<DropdownMenu>`.
+ */
+declare const TableActionCell: React.ForwardRefExoticComponent<Omit<TableActionCellProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface TableToolbarProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /**
+     * Left-aligned controls — typically a search Input plus zero or more
+     * filter SelectFields / DatePickers / Toggles. Children flow horizontally
+     * with `gap` and wrap on narrow screens.
+     */
+    children?: React.ReactNode;
+    /**
+     * Right-aligned slot — for reset / clear / bulk-action buttons. Pushed to
+     * the end of the row via auto-margin; wraps to a new line on narrow
+     * screens if the controls grow too wide.
+     */
+    actions?: React.ReactNode;
+    /**
+     * Render a 1px subtle bottom border to separate the toolbar from the
+     * Table or content below. Default `true`.
+     */
+    divider?: boolean;
+}
+/**
+ * Container for the row of controls (search, filters, actions) that sits
+ * above a `Table` inside a `TableCard`. Presentational only — consumers
+ * own all filter state and search debouncing. The companion to
+ * `TableSearch` for the more common single-search case.
+ */
+declare const TableToolbar: React.ForwardRefExoticComponent<TableToolbarProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const toggleVariants: (props?: ({
+    variant?: "contained" | "outlined" | "ghost" | null | undefined;
+    theme?: "primary" | "secondary" | "destructive" | "success" | "warning" | "info" | "slate" | "inherit" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | null | undefined;
+    iconOnly?: boolean | null | undefined;
+    rounded?: boolean | "extra" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface ToggleProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange'>, VariantProps<typeof toggleVariants> {
+    pressed?: boolean;
+    defaultPressed?: boolean;
+    onPressedChange?: (pressed: boolean) => void;
+    value?: string;
+}
+declare const Toggle: React.ForwardRefExoticComponent<ToggleProps & React.RefAttributes<HTMLButtonElement>>;
+
+type ToggleGroupBaseProps = VariantProps<typeof toggleVariants> & {
+    className?: string;
+    children?: React.ReactNode;
+    stretch?: boolean;
+};
+type ToggleGroupSingleProps = ToggleGroupBaseProps & {
+    type: 'single';
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+};
+type ToggleGroupMultipleProps = ToggleGroupBaseProps & {
+    type: 'multiple';
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+};
+type ToggleGroupProps = ToggleGroupSingleProps | ToggleGroupMultipleProps;
+declare const ToggleGroup: React.ForwardRefExoticComponent<ToggleGroupProps & React.RefAttributes<HTMLDivElement>>;
+
+export { DialogHeader as B, Chip as C, DevIndicator as D, DialogOverlay as E, DialogPortal as F, DialogTitle as H, DialogTrigger as I, EmptyState as K, Icon as M, List as O, ListItem as P, Pagination as T, ProgressBar as V, Separator as Y, Alert as a, StatCard as a0, StepProgress as a7, Switch as a9, Table as ab, TableActionCell as ac, TableBody as af, TableCard as ah, TableCell as ai, TableFooter as aj, TableHead as ak, TableHeader as al, TableRow as am, TableSortableHeader as an, TableToolbar as ap, Toggle as ar, ToggleGroup as as, persistAlert as aw, AlertBanner as b, AlertDescription as d, AlertProvider as g, AlertTitle as i, Avatar as j, AvatarFallback as k, AvatarImage as m, CodeBlock as q, Dialog as t, DialogClose as u, DialogContent as w, DialogDescription as y, DialogFooter as z };
+export type { SortDirection as $, AlertContextValue as A, DialogProps as G, DialogTriggerProps as J, EmptyStateProps as L, IconProps as N, ListItemProps as Q, ListProps as R, SortState as S, PaginationProps as U, ProgressBarProps as W, PushAlertInput as X, SeparatorProps as Z, SortContextValue as _, StatCardDirection as a1, StatCardProps as a2, StatCardSize as a3, StatCardTheme as a4, StatCardVariant as a5, Step as a6, StepProgressProps as a8, SwitchProps as aa, TableActionCellProps as ad, TableActionItem as ae, TableBodyProps as ag, TableSortableHeaderProps as ao, TableToolbarProps as aq, ToggleGroupProps as at, ToggleProps as au, TrendDirection as av, AlertBannerProps as c, AlertMessage as e, AlertProps as f, AlertTheme as h, AvatarFallbackProps as l, AvatarImageProps as n, AvatarProps as o, ChipProps as p, CodeBlockProps as r, DevIndicatorProps as s, DialogCloseProps as v, DialogContentProps as x };