@lucasvu/scope-ui 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,842 @@
+import * as react from 'react';
+import { ReactNode, CSSProperties, SVGProps, ButtonHTMLAttributes, InputHTMLAttributes, HTMLAttributes, FormHTMLAttributes, LabelHTMLAttributes, TableHTMLAttributes, TdHTMLAttributes, ThHTMLAttributes, RefObject, ElementType } from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as SelectPrimitive from '@radix-ui/react-select';
+
+type ComponentSize = 'sm' | 'md' | 'lg';
+interface SharedComponentProps {
+    label?: ReactNode;
+    helperText?: ReactNode;
+    errorMessage?: ReactNode;
+    loading?: boolean;
+    disabled?: boolean;
+    size?: ComponentSize;
+    className?: string;
+    style?: CSSProperties;
+}
+declare const spinnerSizes: Record<'xs' | 'sm' | 'md' | 'lg', string>;
+interface LoadingSpinnerProps extends SVGProps<SVGSVGElement> {
+    size?: keyof typeof spinnerSizes;
+}
+
+declare const alertVariants: (props?: ({
+    variant?: "default" | "info" | "success" | "warning" | "destructive" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type AlertVariant = NonNullable<VariantProps<typeof alertVariants>['variant']>;
+type AlertTone = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+interface AlertProps extends SharedComponentProps {
+    description?: ReactNode;
+    icon?: ReactNode;
+    tone?: AlertTone;
+    variant?: AlertVariant;
+    title?: ReactNode;
+    children?: ReactNode;
+}
+/**
+ * Status-aware alert panel with selectable variants, helper text, and optional iconography.
+ * @remarks
+ * Use `variant` (default/info/success/warning/destructive) and `size` (sm/md/lg) to tune the tone, show `description` or `helperText`, and decorate with a spinner via `loading`.
+ */
+declare const Alert: react.ForwardRefExoticComponent<AlertProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const badgeVariants: (props?: ({
+    variant?: "success" | "warning" | "destructive" | "solid" | "outline" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type BadgeVariant = VariantProps<typeof badgeVariants>['variant'];
+interface BadgeProps extends SharedComponentProps {
+    variant?: BadgeVariant;
+    text?: ReactNode;
+    children?: ReactNode;
+}
+/**
+ * Compact badge that communicates status or metadata with variant styling and optional loading state.
+ * @remarks
+ * Choose `variant` (solid/outline/success/warning/destructive) and `size` (sm/md/lg), add helper text, and optionally display `loading` or `disabled` states.
+ */
+declare function Badge({ variant, size, label, helperText, errorMessage, loading, disabled, className, style, text, children, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+type BreadcrumbItem = {
+    label: ReactNode;
+    onClick?: () => void;
+    href?: string;
+    current?: boolean;
+};
+type BreadcrumbProps = {
+    items: BreadcrumbItem[];
+    className?: string;
+    separator?: ReactNode;
+};
+declare function Breadcrumb({ items, className, separator, }: BreadcrumbProps): react_jsx_runtime.JSX.Element;
+
+declare const buttonVariants$1: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "confirm" | "secondary" | "ghost" | "create" | null | undefined;
+    size?: "sm" | "md" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonVariant$1 = VariantProps<typeof buttonVariants$1>['variant'];
+type ButtonSize$1 = 'sm' | 'md' | 'lg' | 'icon';
+interface ButtonProps$1 extends Omit<SharedComponentProps, 'size'>, Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'size' | 'className'> {
+    variant?: ButtonVariant$1;
+    size?: ButtonSize$1;
+    startIcon?: ReactNode;
+    endIcon?: ReactNode;
+    children?: ReactNode;
+}
+/**
+ * Primary action button with shadcn-inspired variants, helper text, and optional loading rewards.
+ * @remarks
+ * Support `variant` (default/destructive/outline/secondary/ghost/link) and `size` (sm/md/lg), adorn with icons, and surface helper or error text without needing custom wrappers.
+ */
+declare const Button$1: react.ForwardRefExoticComponent<ButtonProps$1 & react.RefAttributes<HTMLButtonElement>>;
+
+declare const inputVariants$1: (props?: ({
+    variant?: "default" | "outline" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type InputVariant$1 = VariantProps<typeof inputVariants$1>['variant'];
+interface InputProps$1 extends SharedComponentProps, Omit<InputHTMLAttributes<HTMLInputElement>, 'className' | 'size' | 'prefix'> {
+    variant?: InputVariant$1;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    inputClassName?: string;
+    onValueChange?: (value: string) => void;
+    showPasswordToggle?: boolean;
+}
+/**
+ * Accessible input surface with shadcn styling, optional prefix/suffix, and helpers for feedback.
+ * @remarks
+ * Swap `variant` (default/ghost/outline) and `size` (sm/md/lg), keep adornments with `prefix`/`suffix`, display helper/error text, and show a spinner via `loading`.
+ */
+declare const Input$1: react.ForwardRefExoticComponent<InputProps$1 & react.RefAttributes<HTMLInputElement>>;
+
+type FormatOnBlur = 'trim' | 'fixed' | 'none';
+type NumericMode = 'integer' | 'decimal';
+type DecimalSeparator = '.' | ',' | 'auto';
+
+interface NumericInputProps extends Omit<InputProps$1, 'type' | 'inputMode' | 'value' | 'defaultValue' | 'onChange' | 'onValueChange'>, Pick<InputHTMLAttributes<HTMLInputElement>, 'onBlur' | 'onFocus' | 'name'> {
+    value?: string | number;
+    defaultValue?: string | number;
+    onValueChange?: (raw: string) => void;
+    onNumberChange?: (num: number | null) => void;
+    mode?: NumericMode;
+    decimalScale?: number;
+    maxDecimalScale?: number;
+    scale?: number;
+    min?: number;
+    max?: number;
+    allowNegative?: boolean;
+    decimalSeparator?: DecimalSeparator;
+    formatOnBlur?: FormatOnBlur;
+    clampOnBlur?: boolean;
+}
+declare const NumericInput: react.ForwardRefExoticComponent<NumericInputProps & react.RefAttributes<HTMLInputElement>>;
+
+declare function Card$1({ className, ...props }: react.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardHeader$1({ className, ...props }: react.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardTitle$1({ className, ...props }: react.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardDescription$1({ className, ...props }: react.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardAction$1({ className, ...props }: react.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardContent$1({ className, ...props }: react.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardFooter$1({ className, ...props }: react.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+
+type ComboboxOption$2 = {
+    label: string;
+    value: string | number;
+    description?: string;
+    searchValue?: string;
+    disabled?: boolean;
+};
+interface ComboboxProps$1 extends SharedComponentProps {
+    options: ComboboxOption$2[];
+    value?: string | number;
+    placeholder?: string;
+    onChange?: (value: ComboboxOption$2['value']) => void;
+    onInputChange?: (value: string) => void;
+    loading?: boolean;
+    disabled?: boolean;
+    searchPlaceholder?: string;
+    helperId?: string;
+    errorId?: string;
+    allowClear?: boolean;
+    onClear?: () => void;
+    portal?: boolean;
+}
+declare const Combobox$1: react.ForwardRefExoticComponent<ComboboxProps$1 & react.RefAttributes<HTMLInputElement>>;
+
+type ComboboxOption$1 = {
+    label: string;
+    value: string | number;
+    description?: string;
+    searchValue?: string;
+    disabled?: boolean;
+};
+interface AsyncComboboxProps extends SharedComponentProps {
+    options: ComboboxOption$1[];
+    value?: string | number;
+    placeholder?: string;
+    onChange?: (value: ComboboxOption$1['value']) => void;
+    onInputChange?: (value: string) => void;
+    onInputFocus?: () => void;
+    onScrollEnd?: () => void;
+    loading?: boolean;
+    disabled?: boolean;
+    searchPlaceholder?: string;
+    helperId?: string;
+    errorId?: string;
+    allowClear?: boolean;
+    onClear?: () => void;
+    portal?: boolean;
+}
+declare const AsyncCombobox: react.ForwardRefExoticComponent<AsyncComboboxProps & react.RefAttributes<HTMLInputElement>>;
+
+type MultiSelectOption = {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+    searchValue?: string;
+};
+interface MultiSelectProps extends SharedComponentProps {
+    options: MultiSelectOption[];
+    value?: Array<MultiSelectOption['value']>;
+    placeholder?: string;
+    onChange?: (value: Array<MultiSelectOption['value']>) => void;
+    onSearch?: (value: string) => void;
+    loading?: boolean;
+    disabled?: boolean;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+}
+declare const MultiSelect: react.ForwardRefExoticComponent<MultiSelectProps & react.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Vertical form wrapper that keeps consistent spacing between fields.
+ * @remarks
+ * Extend `className` or pass native form props while maintaining consistent letter spacing for each child row.
+ */
+declare function Form({ className, ...props }: FormHTMLAttributes<HTMLFormElement>): react_jsx_runtime.JSX.Element;
+interface FormFieldProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+/**
+ * Grid-aligned form field wrapper for label/control/description clusters.
+ */
+declare const FormField: react.ForwardRefExoticComponent<FormFieldProps & react.RefAttributes<HTMLDivElement>>;
+/**
+ * Container for a single form item to stack label, control, and messages vertically.
+ */
+declare const FormItem: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+/**
+ * Styled label with strong typography and surface-aware coloring.
+ */
+declare const FormLabel: react.ForwardRefExoticComponent<LabelHTMLAttributes<HTMLLabelElement> & react.RefAttributes<HTMLLabelElement>>;
+/**
+ * Flex container that aligns inputs and accessory controls horizontally.
+ */
+declare const FormControl: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+/**
+ * Neutral description text for a form field.
+ */
+declare const FormDescription: react.ForwardRefExoticComponent<HTMLAttributes<HTMLParagraphElement> & react.RefAttributes<HTMLParagraphElement>>;
+/**
+ * Inline error message text for destructive validation states.
+ */
+declare const FormMessage: react.ForwardRefExoticComponent<HTMLAttributes<HTMLParagraphElement> & react.RefAttributes<HTMLParagraphElement>>;
+
+type Option = {
+    label: ReactNode;
+    value: string | number;
+    disabled?: boolean;
+};
+declare const triggerVariants$1: (props?: ({
+    variant?: "default" | "outline" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type SelectVariant$1 = VariantProps<typeof triggerVariants$1>['variant'];
+interface SelectProps extends SharedComponentProps, Omit<SelectPrimitive.SelectProps, 'defaultValue' | 'value' | 'children' | 'onValueChange'> {
+    options: Option[];
+    value?: string | number;
+    defaultValue?: string | number;
+    placeholder?: string;
+    onChange?: (value: Option['value']) => void;
+    variant?: SelectVariant$1;
+}
+/**
+ * Select field powered by Radix primitives with customizable trigger variants and accessible helpers.
+ * @remarks
+ * Provide `options`, manage `value`/`defaultValue`, and style via `variant` (default/outline/ghost) plus `size` (sm/md/lg); show helper/error text and `loading`.
+ */
+declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLButtonElement>>;
+
+type SearchableSelectOption = {
+    label: ReactNode;
+    value: string | number;
+    disabled?: boolean;
+    searchValue?: string;
+};
+declare const triggerVariants: (props?: ({
+    variant?: "default" | "outline" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type SelectVariant = VariantProps<typeof triggerVariants>['variant'];
+interface SearchableSelectProps extends SharedComponentProps, Omit<SelectPrimitive.SelectProps, 'defaultValue' | 'value' | 'children' | 'onValueChange'> {
+    options: SearchableSelectOption[];
+    value?: string | number;
+    defaultValue?: string | number;
+    placeholder?: string;
+    onChange?: (value: SearchableSelectOption['value']) => void;
+    variant?: SelectVariant;
+    onSearch?: (query: string) => void;
+    loading?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    searchPlaceholder?: string;
+}
+declare const SearchableSelect: react.ForwardRefExoticComponent<SearchableSelectProps & react.RefAttributes<HTMLButtonElement>>;
+
+type Trend = 'up' | 'down' | 'flat';
+interface StatProps extends SharedComponentProps {
+    value: ReactNode;
+    helper?: ReactNode;
+    delta?: ReactNode;
+    trend?: Trend;
+}
+/**
+ * Metric card that exposes a primary `value`, optional `delta`, and severity-aware `trend` indicator.
+ * @remarks
+ * Accepts `size` (sm/md/lg), shows `helper` or helper text, and can render `loading`/`disabled` states while aligning helper/error messaging.
+ */
+declare function Stat({ label, value, helper, delta, trend, helperText, errorMessage, loading, disabled, size, className, style, }: StatProps): react_jsx_runtime.JSX.Element;
+
+type DataTableSortDirection$1 = 'asc' | 'desc';
+type DataTableAlign$1 = 'left' | 'center' | 'right';
+type DataTableSortState$1 = {
+    key: string;
+    direction: DataTableSortDirection$1;
+};
+type DataTableColumn$1<T> = {
+    key: string;
+    title: ReactNode;
+    dataIndex?: keyof T;
+    width?: number | string;
+    render?: (value: T[keyof T] | undefined, record: T, index: number) => ReactNode;
+    sortable?: boolean;
+    sorter?: (a: T, b: T) => number;
+    sortValue?: (record: T) => string | number | Date | null | undefined;
+    headerAlign?: DataTableAlign$1;
+    cellAlign?: DataTableAlign$1;
+};
+type DataTablePagination$1 = {
+    page: number;
+    pageSize: number;
+    total: number;
+    onChange: (page: number) => void;
+    pageSizeOptions?: number[];
+    onPageSizeChange?: (pageSize: number) => void;
+};
+type RowKey$1 = string | number;
+type DataTableRowSelection$1 = {
+    selectedRowKeys: Array<RowKey$1>;
+    onChange: (selectedRowKeys: Array<RowKey$1>) => void;
+};
+type DataTableProps$1<T> = {
+    columns: Array<DataTableColumn$1<T>>;
+    data: T[];
+    rowKey: keyof T | ((record: T) => RowKey$1);
+    loading?: boolean;
+    emptyText?: ReactNode;
+    pagination?: DataTablePagination$1;
+    sort?: DataTableSortState$1 | null;
+    onSortChange?: (sort: DataTableSortState$1 | null) => void;
+    sortMode?: 'client' | 'server';
+    onRowClick?: (record: T) => void;
+    rowSelection?: DataTableRowSelection$1;
+    renderActions?: (record: T) => ReactNode;
+    className?: string;
+    headerAlign?: DataTableAlign$1;
+    cellAlign?: DataTableAlign$1;
+    stickyOffset?: number;
+    /** When false, table container does not scroll (overflow-visible). Default true. */
+    scrollable?: boolean;
+};
+declare function DataTable$1<T>({ columns, data, rowKey, loading, emptyText, pagination, sort, onSortChange, sortMode, onRowClick, rowSelection, renderActions, className, headerAlign, stickyOffset, scrollable, }: DataTableProps$1<T>): react_jsx_runtime.JSX.Element;
+declare const Table$1: react.ForwardRefExoticComponent<TableHTMLAttributes<HTMLTableElement> & react.RefAttributes<HTMLTableElement>>;
+declare const TableHeader$1: react.ForwardRefExoticComponent<HTMLAttributes<HTMLTableSectionElement> & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody$1: react.ForwardRefExoticComponent<HTMLAttributes<HTMLTableSectionElement> & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow$1: react.ForwardRefExoticComponent<HTMLAttributes<HTMLTableRowElement> & react.RefAttributes<HTMLTableRowElement>>;
+declare const TableCell$1: react.ForwardRefExoticComponent<TdHTMLAttributes<HTMLTableCellElement> & ThHTMLAttributes<HTMLTableCellElement> & {
+    as?: "td" | "th";
+} & react.RefAttributes<HTMLTableCellElement>>;
+
+type PaginationInfo = {
+    page: number;
+    pageSize: number;
+    total: number;
+    totalPages: number;
+    showingStart: number;
+    showingEnd: number;
+};
+type PaginationProps = {
+    page: number;
+    pageSize: number;
+    total: number;
+    onChange: (page: number) => void;
+    pageSizeOptions?: number[];
+    onPageSizeChange?: (pageSize: number) => void;
+    className?: string;
+    showFirstLast?: boolean;
+    label?: (info: PaginationInfo) => ReactNode;
+};
+declare const Pagination: ({ page, pageSize, total, onChange, pageSizeOptions, onPageSizeChange, className, showFirstLast, label, }: PaginationProps) => react_jsx_runtime.JSX.Element;
+
+type PageTitleProps = {
+    title: string;
+    subtitle?: string;
+    size?: 'default' | 'compact';
+    rightSlot?: React.ReactNode;
+};
+declare function PageTitle$1({ title, subtitle, size, rightSlot, }: PageTitleProps): react_jsx_runtime.JSX.Element;
+
+type SectionTitleProps$1 = {
+    title: string;
+    subtitle?: string;
+    icon?: ReactNode;
+    iconClassName?: string;
+    rightSlot?: ReactNode;
+};
+declare function SectionTitle$1({ title, subtitle, icon, iconClassName, rightSlot, }: SectionTitleProps$1): react_jsx_runtime.JSX.Element;
+
+interface TabItem {
+    value: string;
+    label: ReactNode;
+    content: ReactNode;
+    badge?: ReactNode;
+}
+interface TabsProps {
+    items: TabItem[];
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    className?: string;
+    listClassName?: string;
+    contentClassName?: string;
+}
+declare function Tabs({ items, defaultValue, onChange, className, listClassName, contentClassName, }: TabsProps): react_jsx_runtime.JSX.Element;
+
+interface LoadingProps extends HTMLAttributes<HTMLDivElement> {
+    label?: ReactNode;
+    size?: LoadingSpinnerProps['size'];
+}
+declare function Loading({ label, size, className, ...props }: LoadingProps): react_jsx_runtime.JSX.Element;
+
+type TooltipSide$2 = 'top' | 'right' | 'bottom' | 'left';
+type TooltipAlign$2 = 'start' | 'center' | 'end';
+type TooltipProps = {
+    content: ReactNode;
+    children: ReactNode;
+    side?: TooltipSide$2;
+    align?: TooltipAlign$2;
+    className?: string;
+    contentClassName?: string;
+    wrap?: boolean;
+    portal?: boolean;
+};
+declare function Tooltip({ content, children, side, align, className, contentClassName, wrap, portal, }: TooltipProps): react_jsx_runtime.JSX.Element;
+
+type TooltipSide$1 = 'top' | 'right' | 'bottom' | 'left';
+type TooltipAlign$1 = 'start' | 'center' | 'end';
+type OverflowTooltipProps = {
+    content: ReactNode;
+    children: ReactNode;
+    targetRef?: RefObject<HTMLElement | null>;
+    side?: TooltipSide$1;
+    align?: TooltipAlign$1;
+    className?: string;
+    contentClassName?: string;
+    wrap?: boolean;
+    portal?: boolean;
+    disabled?: boolean;
+    watch?: ReadonlyArray<unknown>;
+};
+declare function OverflowTooltip({ content, children, targetRef, side, align, className, contentClassName, wrap, portal, disabled, watch, }: OverflowTooltipProps): react_jsx_runtime.JSX.Element;
+
+type TooltipSide = 'top' | 'right' | 'bottom' | 'left';
+type TooltipAlign = 'start' | 'center' | 'end';
+type LineClampTooltipProps = {
+    text: string;
+    lineClamp?: number;
+    className?: string;
+    side?: TooltipSide;
+    align?: TooltipAlign;
+    wrap?: boolean;
+    portal?: boolean;
+};
+declare function LineClampTooltip({ text, lineClamp, className, side, align, wrap, portal, }: LineClampTooltipProps): react_jsx_runtime.JSX.Element;
+
+type TruncatedTextProps = {
+    email: string;
+};
+declare function TruncatedText({ email, }: TruncatedTextProps): react_jsx_runtime.JSX.Element;
+
+type SidebarItem$1 = {
+    id: string;
+    title?: string;
+    titleKey?: string;
+    icon?: ReactNode | ElementType;
+    href?: string;
+    permission?: string | string[];
+    children?: SidebarItem$1[];
+};
+type PermissionChecker = (permission: string | string[] | undefined, userPermissions?: string[]) => boolean;
+interface SidebarProps extends HTMLAttributes<HTMLElement> {
+    items: SidebarItem$1[];
+    userPermissions?: string[];
+    permissionChecker?: PermissionChecker;
+    activeItemId?: string;
+    onItemClick?: (item: SidebarItem$1) => void;
+    listClassName?: string;
+    nestedListClassName?: string;
+    itemClassName?: string;
+    indentSize?: number;
+    ariaLabel?: string;
+    collapsible?: boolean;
+    collapsed?: boolean;
+    defaultCollapsed?: boolean;
+    onCollapseChange?: (collapsed: boolean) => void;
+    collapsedWidth?: number | string;
+    expandedWidth?: number | string;
+    collapseButtonLabel?: string;
+}
+
+declare function Sidebar({ items, userPermissions, permissionChecker, activeItemId, onItemClick, listClassName, nestedListClassName, itemClassName, indentSize, ariaLabel, className, collapsible, collapsed, defaultCollapsed, onCollapseChange, collapsedWidth, expandedWidth, collapseButtonLabel, style, ...rest }: SidebarProps): react_jsx_runtime.JSX.Element;
+
+type SidebarItemProps = {
+    item: SidebarItem$1;
+    depth: number;
+    activeItemId?: string;
+    onItemClick?: (item: SidebarItem$1) => void;
+    indentSize?: number;
+    nestedListClassName?: string;
+    itemClassName?: string;
+    collapsed?: boolean;
+};
+declare function SidebarItem({ item, depth, activeItemId, onItemClick, indentSize, nestedListClassName, itemClassName, collapsed, }: SidebarItemProps): react_jsx_runtime.JSX.Element;
+
+declare const defaultPermissionChecker: PermissionChecker;
+declare function filterSidebarItems(items: SidebarItem$1[], userPermissions: string[] | undefined, permissionChecker?: PermissionChecker): SidebarItem$1[];
+declare function hasActiveDescendant(item: SidebarItem$1, activeItemId?: string): boolean;
+
+type ArgonSidebarHeaderRender = (state: {
+    collapsed: boolean;
+    hoverExpanded: boolean;
+}) => React.ReactNode;
+type ArgonSidebarProps = SidebarProps & {
+    onHoverChange?: (hovered: boolean) => void;
+    header?: React.ReactNode | ArgonSidebarHeaderRender;
+};
+declare function ArgonSidebar({ items, userPermissions, permissionChecker, activeItemId, onItemClick, listClassName, nestedListClassName, itemClassName, indentSize, ariaLabel, className, collapsible, collapsed, defaultCollapsed, onCollapseChange, collapsedWidth, expandedWidth, collapseButtonLabel, style, onHoverChange, header, ...rest }: ArgonSidebarProps): react_jsx_runtime.JSX.Element;
+
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "confirm" | "secondary" | "ghost" | "create" | null | undefined;
+    size?: "sm" | "md" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonVariant = VariantProps<typeof buttonVariants>['variant'];
+type ButtonSize = 'sm' | 'md' | 'lg' | 'icon';
+interface ButtonProps extends Omit<SharedComponentProps, 'size'>, Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'size' | 'className'> {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    startIcon?: ReactNode;
+    endIcon?: ReactNode;
+    children?: ReactNode;
+}
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+declare function Card({ className, ...props }: react.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardHeader({ className, ...props }: react.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardTitle({ className, ...props }: react.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardDescription({ className, ...props }: react.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardAction({ className, ...props }: react.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardContent({ className, ...props }: react.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardFooter({ className, ...props }: react.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+
+type SectionTitleProps = {
+    title: string;
+    subtitle?: string;
+    icon?: ReactNode;
+    iconClassName?: string;
+    rightSlot?: ReactNode;
+};
+declare function SectionTitle({ title, subtitle, icon, iconClassName, rightSlot, }: SectionTitleProps): react_jsx_runtime.JSX.Element;
+
+declare const inputVariants: (props?: ({
+    variant?: "default" | "outline" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type InputVariant = VariantProps<typeof inputVariants>['variant'];
+interface InputProps extends SharedComponentProps, Omit<InputHTMLAttributes<HTMLInputElement>, 'className' | 'size' | 'prefix'> {
+    variant?: InputVariant;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    inputClassName?: string;
+    onValueChange?: (value: string) => void;
+    showPasswordToggle?: boolean;
+}
+declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
+
+type ComboboxOption = {
+    label: string;
+    value: string | number;
+    description?: string;
+    searchValue?: string;
+    disabled?: boolean;
+};
+type ComboboxAsyncConfig = {
+    onSearch?: (value: string) => void;
+    onLoadMore?: () => void;
+    hasMore?: boolean;
+    resetSearchOnFocus?: boolean;
+    restoreSelectedOnBlur?: boolean;
+};
+interface ComboboxProps extends SharedComponentProps {
+    options: ComboboxOption[];
+    value?: string | number;
+    placeholder?: string;
+    onChange?: (value: ComboboxOption['value']) => void;
+    onInputChange?: (value: string) => void;
+    onLoadMore?: () => void;
+    hasMore?: boolean;
+    asyncConfig?: ComboboxAsyncConfig;
+    loading?: boolean;
+    disabled?: boolean;
+    searchPlaceholder?: string;
+    helperId?: string;
+    errorId?: string;
+    allowClear?: boolean;
+    onClear?: () => void;
+    portal?: boolean;
+    dropdownClassName?: string;
+    /** Override dropdown max height (e.g. for testing scroll with few items). */
+    dropdownMaxHeight?: number;
+    /** Keep error state styling but do not render error text below field. */
+    hideErrorMessage?: boolean;
+}
+declare const Combobox: react.ForwardRefExoticComponent<ComboboxProps & react.RefAttributes<HTMLInputElement>>;
+
+interface SwitchProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size' | 'className' | 'onChange'> {
+    className?: string;
+    trackClassName?: string;
+    thumbClassName?: string;
+    onCheckedChange?: (checked: boolean) => void;
+}
+declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLInputElement>>;
+
+type MultiTabItem = {
+    label: ReactNode;
+    value: string;
+};
+interface MultiTabsProps {
+    items: MultiTabItem[];
+    value: string;
+    onChange: (value: string) => void;
+    className?: string;
+    style?: CSSProperties;
+}
+declare function MultiTabs({ items, value, onChange, className, style, }: MultiTabsProps): react_jsx_runtime.JSX.Element;
+
+type StatTone = 'emerald' | 'sky' | 'violet' | 'rose';
+type StatCardProps = {
+    label: ReactNode;
+    value: ReactNode;
+    tone?: StatTone;
+    icon?: ReactNode;
+    className?: string;
+};
+declare function StatCard({ label, value, tone, icon, className, }: StatCardProps): react_jsx_runtime.JSX.Element;
+
+type DataTableSortDirection = 'asc' | 'desc';
+type DataTableAlign = 'left' | 'center' | 'right';
+type DataTableSortState = {
+    key: string;
+    direction: DataTableSortDirection;
+};
+type DataTableColumn<T> = {
+    key: string;
+    title: ReactNode;
+    dataIndex?: keyof T;
+    width?: number | string;
+    render?: (value: T[keyof T] | undefined, record: T, index: number) => ReactNode;
+    sortable?: boolean;
+    sorter?: (a: T, b: T) => number;
+    sortValue?: (record: T) => string | number | Date | null | undefined;
+    headerAlign?: DataTableAlign;
+    cellAlign?: DataTableAlign;
+};
+type DataTablePagination = {
+    page: number;
+    pageSize: number;
+    total: number;
+    onChange: (page: number) => void;
+    pageSizeOptions?: number[];
+    onPageSizeChange?: (pageSize: number) => void;
+};
+type RowKey = string | number;
+type DataTableRowSelection = {
+    selectedRowKeys: Array<RowKey>;
+    onChange: (selectedRowKeys: Array<RowKey>) => void;
+};
+type DataTableProps<T> = {
+    columns: Array<DataTableColumn<T>>;
+    data: T[];
+    rowKey: keyof T | ((record: T) => RowKey);
+    loading?: boolean;
+    emptyText?: ReactNode;
+    pagination?: DataTablePagination;
+    sort?: DataTableSortState | null;
+    onSortChange?: (sort: DataTableSortState | null) => void;
+    sortMode?: 'client' | 'server';
+    onRowClick?: (record: T) => void;
+    rowSelection?: DataTableRowSelection;
+    renderActions?: (record: T) => ReactNode;
+    actionColumnWidth?: number | string;
+    className?: string;
+    headerAlign?: DataTableAlign;
+    cellAlign?: DataTableAlign;
+    stickyOffset?: number;
+};
+declare function DataTable<T>({ columns, data, rowKey, loading, emptyText, pagination, sort, onSortChange, sortMode, onRowClick, rowSelection, renderActions, actionColumnWidth, className, headerAlign, stickyOffset, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+declare const Table: react.ForwardRefExoticComponent<TableHTMLAttributes<HTMLTableElement> & react.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: react.ForwardRefExoticComponent<HTMLAttributes<HTMLTableSectionElement> & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: react.ForwardRefExoticComponent<HTMLAttributes<HTMLTableSectionElement> & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: react.ForwardRefExoticComponent<HTMLAttributes<HTMLTableRowElement> & react.RefAttributes<HTMLTableRowElement>>;
+declare const TableCell: react.ForwardRefExoticComponent<TdHTMLAttributes<HTMLTableCellElement> & ThHTMLAttributes<HTMLTableCellElement> & {
+    as?: "td" | "th";
+} & react.RefAttributes<HTMLTableCellElement>>;
+
+type StatusAction = {
+    label: ReactNode;
+    color?: string;
+    href?: string;
+    onClick?: () => void;
+};
+type StatusOption = {
+    value: string | number;
+    label: ReactNode;
+    color?: string;
+    action?: StatusAction;
+};
+type StatusPresentation = {
+    label: ReactNode;
+    color?: string;
+    action?: StatusAction;
+};
+declare function getStatusPresentation(status: string | number | null | undefined, options: StatusOption[]): StatusPresentation | null;
+
+type RemoteLoadingProps = {
+    className?: string;
+};
+declare function RemoteLoading({ className }: RemoteLoadingProps): react_jsx_runtime.JSX.Element;
+
+type DateRangePickerValue = {
+    startDate?: string | null;
+    endDate?: string | null;
+};
+interface DateRangePickerProps {
+    value?: DateRangePickerValue;
+    onChange: (next: Required<DateRangePickerValue>) => void;
+    label?: string;
+    placeholder?: string;
+    className?: string;
+}
+declare function DateRangePicker({ value, onChange, label, placeholder, className, }: DateRangePickerProps): react_jsx_runtime.JSX.Element;
+
+type QuickOption = {
+    label: string;
+    value: string;
+};
+interface DateTimePickerProps {
+    label?: ReactNode;
+    placeholder?: string;
+    value?: string;
+    onChange: (value: string) => void;
+    disabled?: boolean;
+    errorMessage?: string;
+    className?: string;
+    parseFormat?: string;
+    outputFormat?: string;
+    displayFormat?: string;
+    minDateTime?: Date;
+    quickOptions?: QuickOption[];
+    onQuickSelect?: (value: string) => void;
+    onClear?: () => void;
+    quickRangesLabel?: string;
+    clearLabel?: string;
+    portal?: boolean;
+}
+declare function DateTimePicker({ label, placeholder, value, onChange, disabled, errorMessage, className, parseFormat, outputFormat, displayFormat, minDateTime, quickOptions, onQuickSelect, onClear, quickRangesLabel, clearLabel, portal, }: DateTimePickerProps): react_jsx_runtime.JSX.Element;
+
+type MainFePageTitleProps = {
+    title: string;
+    subtitle?: string;
+    size?: 'default' | 'compact';
+    topSlot?: React.ReactNode;
+    rightSlot?: React.ReactNode;
+};
+declare function PageTitle({ title, subtitle, size, topSlot, rightSlot, }: MainFePageTitleProps): react_jsx_runtime.JSX.Element;
+
+declare const index_ArgonSidebar: typeof ArgonSidebar;
+declare const index_Badge: typeof Badge;
+type index_BadgeProps = BadgeProps;
+declare const index_Button: typeof Button;
+type index_ButtonProps = ButtonProps;
+declare const index_Card: typeof Card;
+declare const index_CardAction: typeof CardAction;
+declare const index_CardContent: typeof CardContent;
+declare const index_CardDescription: typeof CardDescription;
+declare const index_CardFooter: typeof CardFooter;
+declare const index_CardHeader: typeof CardHeader;
+declare const index_CardTitle: typeof CardTitle;
+declare const index_Combobox: typeof Combobox;
+type index_ComboboxAsyncConfig = ComboboxAsyncConfig;
+type index_ComboboxOption = ComboboxOption;
+type index_ComboboxProps = ComboboxProps;
+declare const index_DataTable: typeof DataTable;
+type index_DataTableAlign = DataTableAlign;
+type index_DataTableColumn<T> = DataTableColumn<T>;
+type index_DataTablePagination = DataTablePagination;
+type index_DataTableProps<T> = DataTableProps<T>;
+type index_DataTableRowSelection = DataTableRowSelection;
+type index_DataTableSortDirection = DataTableSortDirection;
+type index_DataTableSortState = DataTableSortState;
+declare const index_DateRangePicker: typeof DateRangePicker;
+type index_DateRangePickerProps = DateRangePickerProps;
+declare const index_DateTimePicker: typeof DateTimePicker;
+type index_DateTimePickerProps = DateTimePickerProps;
+declare const index_Input: typeof Input;
+type index_InputProps = InputProps;
+type index_MultiTabItem = MultiTabItem;
+declare const index_MultiTabs: typeof MultiTabs;
+type index_MultiTabsProps = MultiTabsProps;
+declare const index_PageTitle: typeof PageTitle;
+declare const index_RemoteLoading: typeof RemoteLoading;
+type index_RemoteLoadingProps = RemoteLoadingProps;
+declare const index_SectionTitle: typeof SectionTitle;
+declare const index_StatCard: typeof StatCard;
+type index_StatusAction = StatusAction;
+type index_StatusOption = StatusOption;
+type index_StatusPresentation = StatusPresentation;
+declare const index_Switch: typeof Switch;
+type index_SwitchProps = SwitchProps;
+declare const index_Table: typeof Table;
+declare const index_TableBody: typeof TableBody;
+declare const index_TableCell: typeof TableCell;
+declare const index_TableHeader: typeof TableHeader;
+declare const index_TableRow: typeof TableRow;
+declare const index_getStatusPresentation: typeof getStatusPresentation;
+declare namespace index {
+  export { index_ArgonSidebar as ArgonSidebar, index_Badge as Badge, type index_BadgeProps as BadgeProps, index_Button as Button, type index_ButtonProps as ButtonProps, index_Card as Card, index_CardAction as CardAction, index_CardContent as CardContent, index_CardDescription as CardDescription, index_CardFooter as CardFooter, index_CardHeader as CardHeader, index_CardTitle as CardTitle, index_Combobox as Combobox, type index_ComboboxAsyncConfig as ComboboxAsyncConfig, type index_ComboboxOption as ComboboxOption, type index_ComboboxProps as ComboboxProps, index_DataTable as DataTable, type index_DataTableAlign as DataTableAlign, type index_DataTableColumn as DataTableColumn, type index_DataTablePagination as DataTablePagination, type index_DataTableProps as DataTableProps, type index_DataTableRowSelection as DataTableRowSelection, type index_DataTableSortDirection as DataTableSortDirection, type index_DataTableSortState as DataTableSortState, index_DateRangePicker as DateRangePicker, type index_DateRangePickerProps as DateRangePickerProps, index_DateTimePicker as DateTimePicker, type index_DateTimePickerProps as DateTimePickerProps, index_Input as Input, type index_InputProps as InputProps, type index_MultiTabItem as MultiTabItem, index_MultiTabs as MultiTabs, type index_MultiTabsProps as MultiTabsProps, index_PageTitle as PageTitle, index_RemoteLoading as RemoteLoading, type index_RemoteLoadingProps as RemoteLoadingProps, index_SectionTitle as SectionTitle, index_StatCard as StatCard, type index_StatusAction as StatusAction, type index_StatusOption as StatusOption, type index_StatusPresentation as StatusPresentation, index_Switch as Switch, type index_SwitchProps as SwitchProps, index_Table as Table, index_TableBody as TableBody, index_TableCell as TableCell, index_TableHeader as TableHeader, index_TableRow as TableRow, index_getStatusPresentation as getStatusPresentation };
+}
+
+type ClassValue = string | false | null | undefined;
+declare function cn(...values: ClassValue[]): string;
+
+export { Alert, type AlertProps, ArgonSidebar, AsyncCombobox, type AsyncComboboxProps, Badge, type BadgeProps, Breadcrumb, type BreadcrumbItem, Button$1 as Button, type ButtonProps$1 as ButtonProps, Card$1 as Card, CardAction$1 as CardAction, CardContent$1 as CardContent, CardDescription$1 as CardDescription, CardFooter$1 as CardFooter, CardHeader$1 as CardHeader, CardTitle$1 as CardTitle, Combobox$1 as Combobox, type ComboboxOption$2 as ComboboxOption, DataTable$1 as DataTable, type DataTableAlign$1 as DataTableAlign, type DataTableColumn$1 as DataTableColumn, type DataTablePagination$1 as DataTablePagination, type DataTableProps$1 as DataTableProps, type DataTableRowSelection$1 as DataTableRowSelection, type DataTableSortDirection$1 as DataTableSortDirection, type DataTableSortState$1 as DataTableSortState, FormField as Field, Form, FormControl, FormDescription, FormField, type FormFieldProps, FormItem, FormLabel, FormMessage, Input$1 as Input, type InputProps$1 as InputProps, LineClampTooltip, type LineClampTooltipProps, Loading, type LoadingProps, index as MainFe, MultiSelect, type MultiSelectOption, NumericInput, type NumericInputProps, type Option, OverflowTooltip, type OverflowTooltipProps, PageTitle$1 as PageTitle, Pagination, type PaginationInfo, type PaginationProps, type PermissionChecker, SearchableSelect, type SearchableSelectOption, type SearchableSelectProps, SectionTitle$1 as SectionTitle, Select, type SelectProps, Sidebar, SidebarItem, type SidebarProps, Stat, type StatProps, type TabItem, Table$1 as Table, TableBody$1 as TableBody, TableCell$1 as TableCell, TableHeader$1 as TableHeader, TableRow$1 as TableRow, Tabs, type TabsProps, Tooltip, type Trend, TruncatedText, type TruncatedTextProps, cn, defaultPermissionChecker, filterSidebarItems, hasActiveDescendant };