@alsha-research/picaso-ui 0.0.0-stage → 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,1348 @@
+import React, { ButtonHTMLAttributes, ReactNode, HTMLAttributes, FC, Dispatch, SetStateAction, InputHTMLAttributes, LabelHTMLAttributes, TableHTMLAttributes, ThHTMLAttributes, TdHTMLAttributes, TextareaHTMLAttributes, ElementType } from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+type AccordionProps = {
+    type?: "single" | "multiple";
+    collapsible?: boolean;
+    className?: string;
+    children: React.ReactNode;
+    expanded?: boolean;
+};
+declare function Accordion({ type, collapsible, className, children, expanded, }: AccordionProps): React.JSX.Element;
+type AccordionItemProps = {
+    value: string;
+    disabled?: boolean;
+    openItems?: string[];
+    handleToggle?: (value: string) => void;
+    children: React.ReactNode;
+    className?: string;
+};
+declare function AccordionItem({ value, disabled, openItems, handleToggle, children, className, }: AccordionItemProps): React.JSX.Element;
+type AccordionTriggerProps = {
+    isOpen?: boolean;
+    children: React.ReactNode;
+    defaultOpen?: boolean;
+    className?: string;
+    triggerIcon?: React.ReactNode;
+};
+declare function AccordionTrigger({ isOpen, children, className, triggerIcon, }: AccordionTriggerProps): React.JSX.Element;
+type AccordionContentProps = {
+    children: React.ReactNode;
+};
+declare function AccordionContent({ children }: AccordionContentProps): React.JSX.Element;
+
+interface BaseProps {
+    type: "image" | "icon" | "text";
+    size?: "sm" | "md" | "lg";
+    className?: string;
+    onClick?: () => void;
+    rounded?: boolean;
+    border?: boolean;
+    borderColor?: string;
+    borderWidth?: string;
+    radius?: string;
+    disabled?: boolean;
+    statusIcon?: JSX.Element;
+    statusPosition?: "top-right" | "top-left" | "bottom-right" | "bottom-left";
+}
+interface ImageProps extends BaseProps {
+    type: "image";
+    src: string;
+    alt?: string;
+}
+interface IconProps extends BaseProps {
+    type: "icon";
+    icon: JSX.Element;
+}
+interface TextProps extends BaseProps {
+    type: "text";
+    text: string;
+}
+type AvatarProps = ImageProps | IconProps | TextProps;
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLDivElement>>;
+
+type AvatarItemProps = Omit<ImageProps, "size"> | Omit<IconProps, "size"> | Omit<TextProps, "size">;
+interface AvatarGroupProps {
+    avatars: AvatarItemProps[];
+    size?: "sm" | "md" | "lg";
+    max?: number;
+    className?: string;
+}
+declare const AvatarGroup: React.ForwardRefExoticComponent<AvatarGroupProps & React.RefAttributes<HTMLDivElement>>;
+
+type BreadcrumbsProps = {
+    children: React.ReactNode;
+    separator?: React.ReactNode;
+    "aria-label": string;
+    containerClasses?: string;
+};
+declare const Breadcrumbs: ({ children, separator, "aria-label": ariaLabel, containerClasses, }: BreadcrumbsProps) => React.JSX.Element;
+
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    children?: ReactNode;
+    startIcon?: JSX.Element;
+    endIcon?: JSX.Element;
+    disabled?: boolean;
+    fullWidth?: boolean;
+    type?: "submit" | "reset" | "button";
+    /**
+     * Optional. Shows a spinner and blocks clicks / form submission while true.
+     * Defaults to false, so existing usages are unaffected.
+     */
+    loading?: boolean;
+    /**
+     * Optional. Where the spinner appears while `loading` is true.
+     * "start" / "end" replace the matching icon (or add the spinner if there is
+     * no icon). "center" overlays the spinner and keeps the button width stable.
+     * Defaults to "start".
+     */
+    loadingPosition?: "start" | "center" | "end";
+    /** Optional. Custom indicator shown instead of the default spinner. */
+    loadingIndicator?: ReactNode;
+}
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "filled" | "outlined" | "soft" | "ghost" | null | undefined;
+    intent?: "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "primary" | "success" | "error" | "warning" | "default" | "bluegray" | "bluelight" | "rose" | "primary-outlined" | "success-outlined" | "error-outlined" | "warning-outlined" | "default-outlined" | "blue-outlined" | "bluegray-outlined" | "bluelight-outlined" | "indigo-outlined" | "purple-outlined" | "violet-outlined" | "pink-outlined" | "rose-outlined" | "orange-outlined" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xs" | "xl" | null | undefined;
+    iconOnly?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface CalendarRange {
+    start: Date | null;
+    end: Date | null;
+}
+interface CalendarBaseProps {
+    /** Optional. Visible month (controlled). Any day inside the month works. */
+    month?: Date;
+    /** Optional. Initial visible month (uncontrolled). Defaults to the selected date or today. */
+    defaultMonth?: Date;
+    /** Optional. Called when the user navigates to another month. */
+    onMonthChange?: (month: Date) => void;
+    /** Optional. Earliest selectable date (inclusive). */
+    min?: Date;
+    /** Optional. Latest selectable date (inclusive). */
+    max?: Date;
+    /** Optional. Return true to make a date unselectable. */
+    isDateDisabled?: (date: Date) => boolean;
+    /** Optional. Days that get a small dot under the number (events, deadlines…). */
+    markedDates?: Date[];
+    /** Optional. Show 1 or 2 months side by side. Defaults to 1. */
+    numberOfMonths?: 1 | 2;
+    /** Optional. Show days of neighbouring months (single-month view only). Defaults to true. */
+    showOutsideDays?: boolean;
+    /** Optional. First day of the week: 0 = Sunday, 1 = Monday. Defaults to 0. */
+    weekStartsOn?: 0 | 1;
+    /** Optional. BCP 47 locale for month and weekday names. Defaults to "en-US". */
+    locale?: string;
+    className?: string;
+    "aria-label"?: string;
+}
+interface CalendarSingleProps extends CalendarBaseProps {
+    mode?: "single";
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (date: Date | null) => void;
+}
+interface CalendarMultipleProps extends CalendarBaseProps {
+    mode: "multiple";
+    value?: Date[];
+    defaultValue?: Date[];
+    onChange?: (dates: Date[]) => void;
+}
+interface CalendarRangeProps extends CalendarBaseProps {
+    mode: "range";
+    value?: CalendarRange;
+    defaultValue?: CalendarRange;
+    onChange?: (range: CalendarRange) => void;
+}
+type CalendarProps = CalendarSingleProps | CalendarMultipleProps | CalendarRangeProps;
+declare const Calendar: {
+    (props: CalendarProps): React.JSX.Element;
+    displayName: string;
+};
+
+declare const calloutVariants: (props?: ({
+    variant?: "filled" | "outlined" | null | undefined;
+    intent?: "primary" | "success" | "error" | "warning" | "default" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xs" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface CalloutProps extends VariantProps<typeof calloutVariants> {
+    children: ReactNode;
+    startIcon?: JSX.Element;
+    endIcon?: JSX.Element;
+    className?: string;
+}
+declare const Callout: React.FC<CalloutProps>;
+
+interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    className?: string;
+}
+interface CardHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    className?: string;
+}
+interface CardTitleProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    children: React.ReactNode;
+    className?: string;
+}
+interface CardDescriptionProps extends React.HTMLAttributes<HTMLParagraphElement> {
+    children: React.ReactNode;
+    className?: string;
+}
+interface CardActionProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    className?: string;
+}
+interface CardContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    className?: string;
+}
+interface CardFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    className?: string;
+}
+declare function Card({ children, className, ...props }: CardProps): React.JSX.Element;
+declare const CardHeader: React.FC<CardHeaderProps>;
+declare const CardTitle: React.FC<CardTitleProps>;
+declare const CardDescription: React.FC<CardDescriptionProps>;
+declare const CardAction: React.FC<CardActionProps>;
+declare const CardContent: React.FC<CardContentProps>;
+declare const CardFooter: React.FC<CardFooterProps>;
+
+declare const checkboxVariant: (props?: ({
+    size?: "sm" | "lg" | "xl" | null | undefined;
+    intent?: "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "primary" | "success" | "error" | "warning" | "default" | "bluegray" | "bluelight" | "rose" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface CheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof checkboxVariant> {
+    size?: "sm" | "lg" | "xl";
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>;
+
+interface ChipProps extends HTMLAttributes<HTMLSpanElement>, VariantProps<typeof chipVariants> {
+    children: ReactNode;
+    dot?: boolean;
+    dotColor?: string;
+    startIcon?: JSX.Element;
+    endIcon?: JSX.Element;
+}
+declare const chipVariants: (props?: ({
+    variant?: "outlined" | "soft" | "solid" | null | undefined;
+    intent?: "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "primary" | "success" | "error" | "warning" | "default" | "bluegray" | "bluelight" | "rose" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const Chip: ({ children, className, size, variant, intent, dot, dotColor, startIcon, endIcon, ...rest }: ChipProps) => React.JSX.Element;
+
+interface CircularProgressBarProps {
+    strokeWidth?: number;
+    size?: number;
+    percentage: number;
+    text?: string;
+    textClassName?: string;
+}
+declare const CircularProgressBar: ({ percentage, size, strokeWidth, text, textClassName, }: CircularProgressBarProps) => React.JSX.Element;
+
+declare const SHADES: readonly [25, 50, 100, 200, 300, 400, 500, 600, 700, 800, 900];
+declare const PALETTE: {
+    readonly primary: {
+        readonly label: "Primary";
+        readonly themed: true;
+        readonly colors: readonly ["#f5faff", "#eff8ff", "#d1e9ff", "#b2ddff", "#84caff", "#53b1fd", "#2e90fa", "#1570ef", "#175cd3", "#1849a9", "#194185"];
+    };
+    readonly gray: {
+        readonly label: "Gray";
+        readonly themed: true;
+        readonly colors: readonly ["#ffffff", "#f9fafb", "#f2f4f7", "#eaecf0", "#d0d5dd", "#98a2b3", "#667085", "#475467", "#344054", "#1d2939", "#101828"];
+    };
+    readonly error: {
+        readonly label: "Error";
+        readonly themed: true;
+        readonly colors: readonly ["#fffbfa", "#fef3f2", "#fee4e2", "#fecdca", "#fda29b", "#f97066", "#f04438", "#d92d20", "#b42318", "#912018", "#7a271a"];
+    };
+    readonly warning: {
+        readonly label: "Warning";
+        readonly themed: true;
+        readonly colors: readonly ["#fffdf5", "#fffaeb", "#fef0c7", "#fedf89", "#fec84b", "#fdb022", "#f79009", "#dc6803", "#b54708", "#93370d", "#7a2e0e"];
+    };
+    readonly success: {
+        readonly label: "Success";
+        readonly themed: true;
+        readonly colors: readonly ["#f6fef9", "#ecfdf3", "#d1fadf", "#a6f4c5", "#6ce9a6", "#32d583", "#12b76a", "#039855", "#027a48", "#05603a", "#054f31"];
+    };
+    readonly blue: {
+        readonly label: "Blue";
+        readonly themed: false;
+        readonly colors: readonly ["#f5faff", "#eff8ff", "#d1e9ff", "#b2ddff", "#84caff", "#53b1fd", "#2e90fa", "#1570ef", "#175cd3", "#1849a9", "#194185"];
+    };
+    readonly bluegray: {
+        readonly label: "Blue gray";
+        readonly themed: false;
+        readonly colors: readonly ["#fcfcfd", "#f8f9fc", "#eaecf5", "#d5d9eb", "#afb5d9", "#717bbc", "#4e5ba6", "#3e4784", "#363f72", "#293056", "#101323"];
+    };
+    readonly bluelight: {
+        readonly label: "Blue light";
+        readonly themed: false;
+        readonly colors: readonly ["#f5fbff", "#f0f9ff", "#e0f2fe", "#b9e6fe", "#7cd4fd", "#36bffa", "#0ba5ec", "#0086c9", "#026aa2", "#065986", "#0b4a6f"];
+    };
+    readonly indigo: {
+        readonly label: "Indigo";
+        readonly themed: false;
+        readonly colors: readonly ["#f5f8ff", "#eef4ff", "#e0eaff", "#c7d7fe", "#a4bcfd", "#8098f9", "#6172f3", "#444ce7", "#3538cd", "#2d31a6", "#2d3282"];
+    };
+    readonly purple: {
+        readonly label: "Purple";
+        readonly themed: false;
+        readonly colors: readonly ["#fafaff", "#f4f3ff", "#ebe9fe", "#d9d6fe", "#bdb4fe", "#9b8afb", "#7a5af8", "#6938ef", "#5925dc", "#4a1fb8", "#3e1c96"];
+    };
+    readonly violet: {
+        readonly label: "Violet";
+        readonly themed: false;
+        readonly colors: readonly ["#fcfaff", "#f9f5ff", "#f4ebff", "#e9d7fe", "#d6bbfb", "#b692f6", "#9e77ed", "#7f56d9", "#6941c6", "#53389e", "#42307d"];
+    };
+    readonly pink: {
+        readonly label: "Pink";
+        readonly themed: false;
+        readonly colors: readonly ["#fef6fb", "#fdf2fa", "#fce7f6", "#fcceee", "#faa7e0", "#f670c7", "#ee46bc", "#dd2590", "#c11574", "#9e165f", "#851651"];
+    };
+    readonly rose: {
+        readonly label: "Rose";
+        readonly themed: false;
+        readonly colors: readonly ["#fff5f6", "#fff1f3", "#ffe4e8", "#fecdd6", "#fea3b4", "#fd6f8e", "#f63d68", "#e31b54", "#c01048", "#a11043", "#89123e"];
+    };
+    readonly orange: {
+        readonly label: "Orange";
+        readonly themed: false;
+        readonly colors: readonly ["#fffaf5", "#fff6ed", "#ffead5", "#fddcab", "#feb273", "#fd853a", "#fb6514", "#ec4a0a", "#c4320a", "#9c2a10", "#7e2410"];
+    };
+};
+type ColorFamily = keyof typeof PALETTE;
+type ColorShade = (typeof SHADES)[number];
+interface ColorPickerToken {
+    family: ColorFamily;
+    shade: ColorShade;
+}
+interface ColorPickerProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "defaultValue" | "placeholder"> {
+    /** Selected colour as a hex string (`#rgb` or `#rrggbb`). Makes the component controlled. */
+    value?: string;
+    /** Initial colour when uncontrolled. */
+    defaultValue?: string;
+    /**
+     * Called with the new colour as a lowercase `#rrggbb` string. When the colour
+     * is one of the theme swatches, the second argument names it
+     * (e.g. `{ family: "primary", shade: 600 }`).
+     */
+    onChange?: (value: string, token?: ColorPickerToken) => void;
+    /** Limit which colour families are offered. Defaults to all theme families. */
+    families?: ColorFamily[];
+    /** Show the hex field and native colour input for colours outside the palette. Defaults to true. */
+    showCustomColor?: boolean;
+    /** Text shown in the trigger while no colour is selected. */
+    placeholder?: string;
+    /** Which side of the trigger the panel opens on. Defaults to "bottom". */
+    placement?: "bottom" | "top";
+    disabled?: boolean;
+    error?: boolean;
+    /** When set, a hidden input carries the hex value so the picker works inside native forms. */
+    name?: string;
+}
+declare const ColorPicker: React.ForwardRefExoticComponent<ColorPickerProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface DateRange {
+    start: Date | null;
+    end: Date | null;
+}
+interface DatePickerBaseProps {
+    /** Optional. Earliest selectable date (inclusive). */
+    min?: Date;
+    /** Optional. Latest selectable date (inclusive). */
+    max?: Date;
+    /** Optional. Return true to make a specific date unselectable (e.g. weekends, holidays). */
+    isDateDisabled?: (date: Date) => boolean;
+    /** Optional. Text shown when nothing is selected. */
+    placeholder?: string;
+    disabled?: boolean;
+    error?: boolean;
+    /** Optional. "sm" = 320px, "lg" = 313px, default = full width (same as Input). */
+    size?: "sm" | "lg";
+    /** Optional. Open the calendar above or below the field. Defaults to "bottom". */
+    placement?: "bottom" | "top";
+    /** Optional. Show a clear button when a value is selected. Defaults to true. */
+    clearable?: boolean;
+    /** Optional. Show a "Today" shortcut in the footer. Defaults to true. */
+    showToday?: boolean;
+    /** Optional. First day of the week: 0 = Sunday, 1 = Monday. Defaults to 0. */
+    weekStartsOn?: 0 | 1;
+    /** Optional. BCP 47 locale used for month and weekday names. Defaults to "en-US". */
+    locale?: string;
+    /** Optional. Intl.DateTimeFormat options for the text shown in the field. */
+    formatOptions?: Intl.DateTimeFormatOptions;
+    id?: string;
+    /** Optional. Adds a hidden input (ISO date, or "start/end" for ranges) for native forms. */
+    name?: string;
+    className?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+}
+interface DatePickerSingleProps extends DatePickerBaseProps {
+    mode?: "single";
+    /** Controlled value. */
+    value?: Date | null;
+    /** Uncontrolled initial value. */
+    defaultValue?: Date | null;
+    onChange?: (date: Date | null) => void;
+}
+interface DateRangePreset {
+    label: string;
+    range: DateRange;
+}
+interface DatePickerRangeProps extends DatePickerBaseProps {
+    mode: "range";
+    /** Optional. Shortcut buttons (e.g. "Last 7 days") shown above the footer. */
+    presets?: DateRangePreset[];
+    /** Controlled value. */
+    value?: DateRange;
+    /** Uncontrolled initial value. */
+    defaultValue?: DateRange;
+    onChange?: (range: DateRange) => void;
+}
+type DatePickerProps = DatePickerSingleProps | DatePickerRangeProps;
+declare const DatePicker: {
+    (props: DatePickerProps): React.JSX.Element;
+    displayName: string;
+};
+
+interface DateTimePickerProps {
+    /** Controlled value: a Date carrying both day and time, or null. */
+    value?: Date | null;
+    /** Uncontrolled initial value. */
+    defaultValue?: Date | null;
+    /** Called with a Date (local time) or null when cleared. */
+    onChange?: (value: Date | null) => void;
+    /** Optional. Earliest selectable moment (date and time). */
+    min?: Date;
+    /** Optional. Latest selectable moment (date and time). */
+    max?: Date;
+    /** Optional. Return true to block a specific day. */
+    isDateDisabled?: (date: Date) => boolean;
+    /** Optional. Time used when a date is picked before any time. Defaults to "00:00". */
+    defaultTime?: string;
+    /** Optional. Time display format. Defaults to "12h". */
+    format?: "12h" | "24h";
+    /** Optional. Minutes between time options. Defaults to 5. */
+    minuteStep?: number;
+    datePlaceholder?: string;
+    timePlaceholder?: string;
+    disabled?: boolean;
+    error?: boolean;
+    /** Optional. Open the popovers above or below. Defaults to "bottom". */
+    placement?: "bottom" | "top";
+    /** Optional. First day of week: 0 = Sunday, 1 = Monday. Defaults to 0. */
+    weekStartsOn?: 0 | 1;
+    /** Optional. BCP 47 locale for month and weekday names. Defaults to "en-US". */
+    locale?: string;
+    /** Optional. Intl options for the date text. */
+    formatOptions?: Intl.DateTimeFormatOptions;
+    /** Optional. Adds a hidden input with a local ISO value ("YYYY-MM-DDTHH:mm"). */
+    name?: string;
+    id?: string;
+    className?: string;
+    "aria-label"?: string;
+}
+/** Date + time in one control. Composes DatePicker and TimePicker around a single Date value. */
+declare const DateTimePicker: {
+    ({ value, defaultValue, onChange, min, max, isDateDisabled, defaultTime, format, minuteStep, datePlaceholder, timePlaceholder, disabled, error, placement, weekStartsOn, locale, formatOptions, name, id, className, "aria-label": ariaLabel, }: DateTimePickerProps): React.JSX.Element;
+    displayName: string;
+};
+
+type SharedProps = Omit<React.ComponentProps<typeof DatePicker>, "mode" | "value" | "defaultValue" | "onChange">;
+interface DateRangePickerProps extends SharedProps {
+    /** Controlled value. */
+    value?: DateRange;
+    /** Uncontrolled initial value. */
+    defaultValue?: DateRange;
+    onChange?: (range: DateRange) => void;
+    /** Optional. Shortcut buttons such as "Last 7 days". See getDefaultRangePresets(). */
+    presets?: DateRangePreset[];
+}
+/** Common presets: Last 7 / 30 days and This month. */
+declare const getDefaultRangePresets: (now?: Date) => DateRangePreset[];
+/** DatePicker locked to range mode. */
+declare const DateRangePicker: {
+    (props: DateRangePickerProps): React.JSX.Element;
+    displayName: string;
+};
+
+interface DividerProps {
+    width?: string;
+    height?: string;
+    position?: "horizontal" | "vertical";
+    className?: string;
+}
+declare const Divider: ({ width, height, position, className, }: DividerProps) => React.JSX.Element;
+
+interface DrawerProps {
+    isOpen: boolean;
+    setIsOpen: Dispatch<SetStateAction<boolean>>;
+    children: ReactNode;
+    position?: "left" | "right" | "top" | "bottom";
+    width?: string;
+    height?: string;
+    className?: string;
+    showCloseButton?: boolean;
+    closeOnOutsideClick?: boolean;
+    /** Optional. Close when Escape is pressed. Defaults to true. */
+    closeOnEscape?: boolean;
+    /** Optional. Accessible name for the drawer. Prefer aria-labelledby if you have a visible title. */
+    "aria-label"?: string;
+    /** Optional. id of the element that titles the drawer. */
+    "aria-labelledby"?: string;
+    /** Optional. id of the element that describes the drawer. */
+    "aria-describedby"?: string;
+}
+declare const Drawer: FC<DrawerProps>;
+
+type Option$1 = {
+    label: string | number;
+    value: string | number;
+    info?: string;
+    addInfo?: string;
+    tooltipContent?: string;
+    disabledOption?: boolean;
+    labelTextColor?: string;
+};
+interface DropdownProps$2 {
+    id?: string;
+    icon?: JSX.Element;
+    options: Option$1[];
+    selected?: Option$1[];
+    setSelected?: React.Dispatch<React.SetStateAction<Option$1[]>>;
+    onApply?: () => void;
+    onReset?: () => void;
+    dropdownText?: string;
+    search?: boolean;
+    multiple?: boolean;
+    renderItem?: (option: Option$1) => React.ReactNode;
+    children?: React.ReactNode;
+    position?: "top" | "bottom";
+    info?: string | number;
+    addInfo?: string | number;
+    tooltipContent?: string;
+    width?: string;
+    dropdownFooter?: boolean | undefined;
+    disabled?: boolean;
+    labelTextColor?: string;
+    footerAction?: React.ReactNode;
+    height?: string;
+}
+declare const Dropdown: React.ForwardRefExoticComponent<DropdownProps$2 & React.RefAttributes<HTMLDivElement>>;
+
+type DropdownAlignment = "left" | "right" | "top" | "bottom" | "center" | "start" | "end";
+interface DropdownProps$1 {
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    triggerRef: React.RefObject<HTMLDivElement>;
+    contentRef: React.RefObject<HTMLDivElement>;
+    registerItem: () => number;
+    menuItemsRef: React.MutableRefObject<(HTMLDivElement | null)[]>;
+    closeMenu: () => void;
+}
+interface SubmenuProps {
+    isSubOpen: boolean;
+    setIsSubOpen: (open: boolean) => void;
+}
+declare function DropdownMenu({ children, }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+declare namespace DropdownMenu {
+    var displayName: string;
+}
+
+declare function DropdownMenuTrigger({ children, dropdownProps, }: {
+    children: React.ReactNode;
+    dropdownProps?: DropdownProps$1;
+}): React.JSX.Element;
+declare namespace DropdownMenuTrigger {
+    var displayName: string;
+}
+declare function DropdownMenuContent({ children, align, className, dropdownProps, }: {
+    children: React.ReactNode;
+    align?: DropdownAlignment;
+    className?: string;
+    dropdownProps?: DropdownProps$1;
+}): React.JSX.Element | null;
+declare namespace DropdownMenuContent {
+    var displayName: string;
+}
+declare function DropdownMenuLabel({ children, className, }: {
+    children: React.ReactNode;
+    className?: string;
+}): React.JSX.Element;
+declare namespace DropdownMenuLabel {
+    var displayName: string;
+}
+declare function DropdownMenuSeparator(): React.JSX.Element;
+declare namespace DropdownMenuSeparator {
+    var displayName: string;
+}
+declare function DropdownMenuItem({ children, onClick, disabled, dropdownProps, className, }: {
+    children: React.ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+    className?: string;
+    dropdownProps?: DropdownProps$1;
+}): React.JSX.Element;
+declare namespace DropdownMenuItem {
+    var displayName: string;
+}
+declare function DropdownMenuSub({ children, dropdownProps, }: {
+    children: React.ReactNode;
+    dropdownProps?: DropdownProps$1;
+}): React.JSX.Element;
+declare namespace DropdownMenuSub {
+    var displayName: string;
+}
+declare function DropdownMenuSubTrigger({ children, submenuProps, dropdownProps, className, }: {
+    children: React.ReactNode;
+    submenuProps?: SubmenuProps;
+    dropdownProps?: DropdownProps$1;
+    className?: string;
+}): React.JSX.Element;
+declare namespace DropdownMenuSubTrigger {
+    var displayName: string;
+}
+declare function DropdownMenuSubContent({ children, submenuProps, dropdownProps, }: {
+    children: React.ReactNode;
+    submenuProps?: SubmenuProps;
+    dropdownProps?: DropdownProps$1;
+}): React.JSX.Element;
+declare namespace DropdownMenuSubContent {
+    var displayName: string;
+}
+
+type Option = {
+    label: string | number;
+    value: string | number;
+    info?: string;
+    addInfo?: string;
+    tooltipContent?: string;
+    disabledOption?: boolean;
+    labelTextColor?: string;
+};
+interface DropdownProps {
+    id?: string;
+    options: Option[];
+    selected?: Option[];
+    setSelected?: React.Dispatch<React.SetStateAction<Option[]>>;
+    onApply?: () => void;
+    onReset?: () => void;
+    dropdownText?: string;
+    search?: boolean;
+    multiple?: boolean;
+    renderItem?: (option: Option) => React.ReactNode;
+    children?: React.ReactNode;
+    trigger?: React.ReactNode;
+    dropdownMenu?: boolean;
+    position?: "top" | "bottom" | "left" | "right";
+    setDropdownMenu?: (value: boolean) => void;
+    info?: string | number;
+    addInfo?: string | number;
+    tooltipContent?: string;
+    width?: string;
+    dropdownFooter?: boolean;
+    disabled?: boolean;
+    labelTextColor?: string;
+    footerAction?: React.ReactNode;
+    height?: string;
+}
+declare const DropdownWithIcon: React.ForwardRefExoticComponent<DropdownProps & React.RefAttributes<HTMLDivElement>>;
+
+interface FileSelectorProps extends InputHTMLAttributes<HTMLInputElement> {
+    component: JSX.Element;
+}
+declare const FileSelector: React.ForwardRefExoticComponent<FileSelectorProps & React.RefAttributes<HTMLInputElement>>;
+
+interface FileUploadProps extends InputHTMLAttributes<HTMLInputElement> {
+    id: string;
+    selectedFile?: File[];
+    setSelectedFile?: (files: File[]) => void;
+    children?: ReactNode;
+    onDelete?: (index: number) => void;
+    title?: string;
+    disabled?: boolean;
+    filePreviewClassName?: string;
+}
+declare const FileUpload: React.ForwardRefExoticComponent<FileUploadProps & React.RefAttributes<HTMLInputElement>>;
+
+interface FileUploadPreviewProps {
+    index: number;
+    file: File;
+    children?: ReactNode;
+    onDelete?: (index: number) => void;
+}
+declare const FileUploadPreview: ({ index, file, children, onDelete, }: FileUploadPreviewProps) => React.JSX.Element;
+
+interface GlobalNavigationProps {
+    isOpen: boolean;
+    setIsOpen: (isOpen: boolean) => void;
+    className?: string;
+    children: React.ReactNode;
+    trigger: JSX.Element;
+    postion?: "bottom-left" | "bottom-right" | "top-left" | "top-right";
+}
+declare const GlobalNavigation: React.ForwardRefExoticComponent<GlobalNavigationProps & React.RefAttributes<HTMLDivElement>>;
+
+interface HelperTextProps extends HTMLAttributes<HTMLSpanElement> {
+    children: ReactNode;
+    size?: "sm" | "lg";
+    error?: boolean;
+}
+declare const HelperText: ({ children, className, size, error }: HelperTextProps) => React.JSX.Element;
+
+interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
+    size?: "sm" | "lg";
+    startIcon?: JSX.Element;
+    endIcon?: JSX.Element;
+    disabled?: boolean;
+    error?: boolean;
+    type: "text" | "url" | "email" | "password" | "number" | "tel" | "search" | "time";
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+
+interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement>, VariantProps<typeof labelVariants> {
+    htmlFor?: string;
+    children: ReactNode;
+    required?: boolean;
+    disabled?: boolean;
+}
+declare const labelVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const Label: ({ children, htmlFor, size, required, disabled, className, ...props }: LabelProps) => React.JSX.Element;
+
+interface ListPaginationProps {
+    count: number;
+    page: number;
+    rowsPerPage: number;
+    onPageChange: (newPage: number) => void;
+    className?: string;
+}
+declare const ListPagination: React.FC<ListPaginationProps>;
+
+interface LoadingProps {
+    width?: string;
+    height?: string;
+    loaderColor?: string;
+    variant?: "light" | "heavy";
+}
+declare const Loading: ({ width, height, loaderColor, variant }: LoadingProps) => React.JSX.Element;
+
+interface ModalProps {
+    children?: ReactNode;
+    showModal?: boolean;
+    closeModal?: boolean;
+    setShowModal: (value: boolean) => void;
+    closeOnOutsideClick?: boolean;
+    className?: string;
+    width?: string;
+    /** Optional. Close when Escape is pressed. Defaults to true. */
+    closeOnEscape?: boolean;
+    /** Optional. Accessible name for the dialog. Prefer aria-labelledby if you have a visible title. */
+    "aria-label"?: string;
+    /** Optional. id of the element that titles the dialog. */
+    "aria-labelledby"?: string;
+    /** Optional. id of the element that describes the dialog. */
+    "aria-describedby"?: string;
+}
+declare function Modal({ children, showModal, setShowModal, closeModal, closeOnOutsideClick, className, width, closeOnEscape, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, "aria-describedby": ariaDescribedBy, }: ModalProps): React.JSX.Element;
+
+interface NoticeProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof noticeVariants> {
+    children?: ReactNode;
+    noticeTitle?: string;
+    variant: "success" | "warning" | "info" | "error" | "default";
+    position?: "top" | "bottom" | "center";
+    showIcon?: boolean;
+    open: boolean;
+    setOpen: (value: boolean) => void;
+}
+declare const noticeVariants: (props?: ({
+    variant?: "success" | "error" | "warning" | "default" | "info" | null | undefined;
+    position?: "center" | "bottom" | "top" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const Notice: ({ children, variant, position, noticeTitle, open, setOpen, showIcon, }: NoticeProps) => React.JSX.Element;
+
+interface OTPInputProps {
+    length: number;
+    onChange: (otp: string) => void;
+    type?: "text" | "password" | "number";
+}
+declare const OTPInput: React.FC<OTPInputProps>;
+
+type TablePaginationProps = {
+    count: number;
+    countVariable?: string;
+    page: number;
+    rowsPerPage: number;
+    rowsPerPageOptions: (number | {
+        label: string;
+        value: number;
+    })[];
+    onPageChange: (newPage: number) => void;
+    onRowsPerPageChange: (newRowsPerPage: number) => void;
+    className?: string;
+    variant?: "primary" | "secondary";
+    itemsPerPage?: boolean;
+};
+declare const Pagination: React.FC<TablePaginationProps>;
+
+type ProgressBarProps = {
+    progress: number;
+    progressText?: string;
+    progressColor: string;
+    progressTextPosition?: "top" | "bottom" | "left" | "right";
+};
+declare const ProgressBar: ({ progress, progressText, progressColor, progressTextPosition, }: ProgressBarProps) => React.JSX.Element;
+
+interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof radioVariants> {
+    size?: "sm" | "lg";
+    disabled?: boolean;
+    checked?: boolean;
+    children?: never;
+}
+declare const radioVariants: (props?: ({
+    size?: "sm" | "lg" | null | undefined;
+    intent?: "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "primary" | "success" | "error" | "warning" | "default" | "bluegray" | "bluelight" | "rose" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const Radio: React.ForwardRefExoticComponent<RadioProps & React.RefAttributes<HTMLInputElement>>;
+
+type UploadStatus = "idle" | "uploading" | "success" | "error";
+interface UploadItem {
+    id: string;
+    file?: File;
+    name?: string;
+    size?: number;
+    progress?: number;
+    status?: UploadStatus;
+    previewUrl?: string;
+}
+interface FileUploadControlProps {
+    items: UploadItem[];
+    onAddFiles: (files: File[]) => void;
+    onUpdateItem?: (id: string, updates: Partial<UploadItem>) => void;
+    onRejectFiles?: (rejected: {
+        file: File;
+        reason: string;
+    }[]) => void;
+    onDelete?: (id: string) => void;
+    onRetry?: (id: string) => void;
+    onPreview?: (id: string) => void;
+    onUpload?: (file: File, onProgress: (progress: number) => void) => Promise<string>;
+    multiple?: boolean;
+    accept?: string;
+    maxSizeMB?: number;
+    className?: string;
+    hintText?: React.ReactNode;
+    showSizeText?: boolean;
+    getFileIcon?: (fileName: string, fileType: string) => React.ReactNode;
+    autoUpload?: boolean;
+    disabled?: boolean;
+}
+declare const defaultGetFileIcon: (fileName: string, fileType: string) => React.JSX.Element;
+declare function FileUploadControl({ items, onAddFiles, onUpdateItem, onRejectFiles, onDelete, onRetry, onPreview, onUpload, multiple, accept, maxSizeMB, className, hintText, showSizeText, getFileIcon, autoUpload, disabled, }: FileUploadControlProps): React.JSX.Element;
+
+interface SelectOption {
+    label: string;
+    value: string | number;
+    /** Optional. Unselectable and skipped by the keyboard. */
+    disabled?: boolean;
+    /** Optional. Secondary line under the label. */
+    description?: string;
+    /** Optional. Icon shown before the label. */
+    icon?: JSX.Element;
+}
+interface SelectGroup {
+    label: string;
+    options: SelectOption[];
+}
+interface SelectProps {
+    /** Flat options, or groups of options. */
+    options: (SelectOption | SelectGroup)[];
+    /** Controlled value. Use null for "nothing selected". */
+    value?: string | number | null;
+    /** Uncontrolled initial value. */
+    defaultValue?: string | number | null;
+    /** Called with the new value (null when cleared) and its option. */
+    onChange?: (value: string | number | null, option: SelectOption | null) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    error?: boolean;
+    /** Optional. "sm" = 320px, "lg" = 313px, default = full width (same as Input). */
+    size?: "sm" | "lg";
+    /** Optional. Open the list above or below. Defaults to "bottom". */
+    placement?: "bottom" | "top";
+    /** Optional. Show a clear button when a value is selected. Defaults to false. */
+    clearable?: boolean;
+    /** Optional. Max height of the list in px. Defaults to 264. */
+    maxHeight?: number;
+    /** Optional. Text shown when options is empty. */
+    emptyText?: string;
+    id?: string;
+    /** Optional. Adds a hidden input for native forms. */
+    name?: string;
+    className?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+}
+declare const Select: {
+    ({ options, value, defaultValue, onChange, placeholder, disabled, error, size, placement, clearable, maxHeight, emptyText, id, name, className, "aria-label": ariaLabel, "aria-describedby": ariaDescribedby, }: SelectProps): React.JSX.Element;
+    displayName: string;
+};
+
+interface NavItem {
+    label: string;
+    href?: string;
+    icon?: React.ReactElement;
+    subItems?: NavItem[];
+}
+interface SidebarProps {
+    children: React.ReactNode;
+    collapsed: boolean;
+    setCollapsed: (collapsed: boolean) => void;
+    scroll?: boolean;
+    dense?: boolean;
+    navItems?: {
+        label: string;
+        items: NavItem[];
+    }[];
+}
+interface SidebarHeaderProps {
+    children: ReactNode;
+    dense?: boolean;
+}
+interface SidebarMenuProps {
+    collapsed: boolean;
+    navItems?: {
+        label: string;
+        items: NavItem[];
+    }[];
+    scroll?: boolean;
+    dense?: boolean;
+}
+interface FooterProps {
+    children: React.ReactNode;
+    collapsed: boolean;
+    setCollapsed: (collapsed: boolean) => void;
+    navItems?: {
+        label: string;
+        items: NavItem[];
+    }[];
+    dense?: boolean;
+}
+declare const Sidebar: React.FC<SidebarProps> & {
+    Header: React.FC<SidebarHeaderProps>;
+    Menu: React.FC<SidebarMenuProps>;
+    Footer: React.FC<FooterProps>;
+};
+
+interface SkeletonProps {
+    width?: string | number;
+    height?: string | number;
+    circle?: boolean;
+    animation?: "wave" | "pulse" | "shimmer";
+}
+declare const Skeleton: React.FC<SkeletonProps>;
+
+interface SliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
+    value: number;
+    min?: number;
+    max?: number;
+    size?: "sm" | "lg";
+}
+declare const Slider: React.ForwardRefExoticComponent<SliderProps & React.RefAttributes<HTMLInputElement>>;
+
+interface SpinnerProps {
+    size?: "xs" | "sm" | "md" | "lg";
+    color?: "primary" | "black" | "gray" | string;
+}
+declare const Spinner: ({ size, color }: SpinnerProps) => React.JSX.Element;
+
+interface SplitButtonProps {
+    children: React.ReactNode;
+    className?: string;
+    size?: 'sm' | 'md' | 'lg';
+    appearance?: 'primary' | 'secondary' | 'warning' | 'danger';
+    compact?: boolean;
+}
+declare const SplitButton: React.ForwardRefExoticComponent<SplitButtonProps & React.RefAttributes<HTMLDivElement>>;
+
+interface StepConfig {
+    name: string;
+    helperName?: string;
+    Component: React.ComponentType<any>;
+}
+interface CheckoutStepperProps {
+    stepsConfig: StepConfig[];
+    currentStep: number;
+    setCurrentStep: (step: number) => void;
+    isComplete: boolean;
+    setIsComplete: (complete: boolean) => void;
+    position?: string;
+}
+declare const Stepper: ({ stepsConfig, currentStep, setCurrentStep, isComplete, setIsComplete, position, }: CheckoutStepperProps) => React.JSX.Element | null;
+
+interface TableProps extends TableHTMLAttributes<HTMLTableElement> {
+    children?: ReactNode;
+    dense?: boolean;
+}
+interface TableHeadProps extends HTMLAttributes<HTMLTableSectionElement> {
+    children?: ReactNode;
+}
+interface TableRowProps extends HTMLAttributes<HTMLTableRowElement> {
+    children?: ReactNode;
+    indent?: boolean;
+}
+interface TableHeadCellProps extends ThHTMLAttributes<HTMLTableCellElement> {
+    children?: ReactNode;
+    icon?: JSX.Element;
+    sticky?: boolean;
+    left?: string;
+    right?: string;
+    stickyIcon?: JSX.Element;
+    shadow?: boolean;
+    shadowRight?: boolean;
+}
+interface TableCellProps extends TdHTMLAttributes<HTMLTableCellElement> {
+    children?: ReactNode;
+    icon?: JSX.Element;
+    sticky?: boolean;
+    left?: string;
+    right?: string;
+    shadow?: boolean;
+    shadowRight?: boolean;
+}
+declare const Table: ({ children, className, dense, ...props }: TableProps) => React.JSX.Element;
+declare const TableHead: ({ children, className, ...props }: TableHeadProps) => React.JSX.Element;
+declare const TableBody: ({ children, className, ...props }: TableHeadProps) => React.JSX.Element;
+declare const TableRow: ({ children, className, indent, ...props }: TableRowProps) => React.JSX.Element;
+declare const TableHeadCell: ({ children, className, icon, sticky, shadow, left, shadowRight, right, ...props }: TableHeadCellProps) => React.JSX.Element;
+declare const TableDataCell: ({ children, className, icon, sticky, shadow, shadowRight, left, right, ...props }: TableCellProps) => React.JSX.Element;
+
+interface TabItem {
+    label: string;
+    value: string;
+}
+interface TabsContainerProps {
+    value: string;
+    children: React.ReactNode;
+    className?: string;
+    position?: "horizontal" | "vertical";
+}
+interface TabListProps extends Partial<TabItem> {
+    onChange: (value: string) => void;
+    ariaLabel?: string;
+    children: React.ReactNode;
+    box?: boolean;
+    pill?: boolean;
+    className?: string;
+    position?: "horizontal" | "vertical";
+    persist?: "url" | "localStorage";
+    persistKey?: string;
+}
+interface TabProps extends TabItem {
+    onChange: (value: string) => void;
+    box?: boolean;
+    pill?: boolean;
+    content?: React.ReactNode;
+    selectedTabValue: string;
+    icon?: JSX.Element;
+    className?: string;
+    tabIndex?: number;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
+    position?: "horizontal" | "vertical";
+    ref?: React.Ref<HTMLButtonElement>;
+}
+interface TabPanelProps {
+    value: string;
+    currentValue: string;
+    children: React.ReactNode;
+    className?: string;
+}
+declare const TabsContainer: React.FC<TabsContainerProps>;
+declare const TabList: React.FC<TabListProps>;
+declare const Tab: React.ForwardRefExoticComponent<Omit<TabProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabPanel: React.FC<TabPanelProps>;
+
+interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> {
+    size?: "sm" | "lg";
+    disabled?: boolean;
+    rows?: number;
+    cols?: number;
+    error?: boolean;
+    children?: ReactNode;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+interface TextInputWithLabelProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
+    intent?: "error" | "default" | "success" | "warning" | "blue" | "primary" | "bluegray" | "bluelight" | "violet" | "indigo" | "purple" | "pink" | "rose" | "orange";
+    placeholder?: string;
+    size?: "sm" | "lg";
+    type?: "number" | "search" | "text" | "url" | "email" | "password" | "tel" | "time";
+    tags: string[];
+    setTags: (tags: string[]) => void;
+}
+declare const TextInputWithLabel: React.FC<TextInputWithLabelProps>;
+
+/** Time is stored as a 24-hour "HH:mm" string, e.g. "09:30" or "17:05". */
+interface TimePickerProps {
+    /** Controlled value ("HH:mm", 24-hour) or null for empty. */
+    value?: string | null;
+    /** Uncontrolled initial value ("HH:mm"). */
+    defaultValue?: string | null;
+    /** Called with "HH:mm" (24-hour) or null when cleared. */
+    onChange?: (time: string | null) => void;
+    /** Optional. Display and picker format. Defaults to "12h". */
+    format?: "12h" | "24h";
+    /** Optional. Minutes between options (1, 5, 10, 15, 30 …). Defaults to 5. */
+    minuteStep?: number;
+    /** Optional. Earliest selectable time ("HH:mm"). */
+    min?: string;
+    /** Optional. Latest selectable time ("HH:mm"). */
+    max?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    error?: boolean;
+    /** Optional. "sm" = 320px, "lg" = 313px, default = full width (same as Input). */
+    size?: "sm" | "lg";
+    /** Optional. Open the picker above or below the field. Defaults to "bottom". */
+    placement?: "bottom" | "top";
+    /** Optional. Show a clear button when a value is set. Defaults to true. */
+    clearable?: boolean;
+    /** Optional. Show a "Now" shortcut. Defaults to true. */
+    showNow?: boolean;
+    id?: string;
+    /** Optional. Adds a hidden input ("HH:mm") for native forms. */
+    name?: string;
+    className?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+}
+declare const TimePicker: {
+    ({ value, defaultValue, onChange, format, minuteStep, min, max, placeholder, disabled, error, size, placement, clearable, showNow, id, name, className, "aria-label": ariaLabel, "aria-describedby": ariaDescribedby, }: TimePickerProps): React.JSX.Element;
+    displayName: string;
+};
+
+interface ToggleProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof toggleVariants> {
+    size?: "sm" | "md" | "lg";
+    disabled?: boolean;
+    children?: never;
+}
+declare const toggleVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    intent?: "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "primary" | "success" | "error" | "warning" | "default" | "bluegray" | "bluelight" | "rose" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const Toggle: React.ForwardRefExoticComponent<ToggleProps & React.RefAttributes<HTMLInputElement>>;
+
+declare const tooltipVariants: (props?: ({
+    position?: "bottom" | "top" | "left" | "right" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TooltipProps extends Omit<HTMLAttributes<HTMLDivElement>, "content">, VariantProps<typeof tooltipVariants> {
+    children: ReactNode;
+    position: "top" | "right" | "bottom" | "left";
+    content: JSX.Element | string;
+}
+declare const Tooltip: React.FC<TooltipProps>;
+
+interface TreeViewProps {
+    children: React.ReactNode;
+    "aria-label": string;
+    flat?: boolean;
+    className?: string;
+    /** Optional array of IDs to expand initially */
+    defaultExpandedIds?: string[];
+    /** Controlled expansion (useful if parent manages state externally) */
+    expandedIds?: string[];
+    /** Callback for when expanded nodes change */
+    onExpandedChange?: (expanded: string[]) => void;
+    /** Allow multiple nodes to be expanded simultaneously */
+    allowMultiple?: boolean;
+    /** Automatically expand all top-level items by default */
+    expandTopLevelByDefault?: boolean;
+}
+interface TreeViewItemProps {
+    id: string;
+    children: React.ReactNode;
+    current?: boolean;
+    className?: string;
+    onSelect?: (id: string) => void;
+    level?: number;
+    expanded?: boolean;
+    onToggle?: (id: string) => void;
+    selected?: boolean;
+    flat?: boolean;
+}
+interface TreeViewSubTreeProps {
+    children: React.ReactNode;
+    state?: "loading";
+    count?: number;
+    className?: string;
+    expanded?: boolean;
+    flat?: boolean;
+}
+declare const TreeView: React.FC<TreeViewProps> & {
+    Item: React.FC<TreeViewItemProps>;
+    SubTree: typeof TreeViewSubTree;
+    LeadingVisual: typeof TreeViewLeadingVisual;
+    TrailingVisual: typeof TreeViewTrailingVisual;
+};
+declare const TreeViewSubTree: React.FC<TreeViewSubTreeProps>;
+declare const TreeViewLeadingVisual: React.FC<{
+    children: React.ReactNode;
+    className?: string;
+}>;
+declare const TreeViewTrailingVisual: React.FC<{
+    children: React.ReactNode;
+    label?: string;
+    className?: string;
+}>;
+
+interface TypographyProps extends HTMLAttributes<HTMLHeadingElement | HTMLParagraphElement>, VariantProps<typeof typographyVariant> {
+    as?: ElementType;
+    children: ReactNode;
+    intent?: "primary" | "success" | "error" | "warning" | "default";
+}
+declare const typographyVariant: (props?: ({
+    variant?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "b1" | "b2" | "b3" | "b4" | "b5" | null | undefined;
+    intent?: "primary" | "success" | "error" | "warning" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const Typography: ({ as, variant, intent, children, className, ...props }: TypographyProps) => React.JSX.Element;
+
+/**
+ * Theme helpers for re-colouring the `primary` scale at runtime.
+ *
+ * Pure functions only: no `window` / `document` access, so this file is safe to
+ * import from server components, client components and during SSR.
+ */
+declare const THEME_SHADES: readonly [25, 50, 100, 200, 300, 400, 500, 600, 700, 800, 900];
+type ThemeShade = (typeof THEME_SHADES)[number];
+type ThemeScale = Record<ThemeShade, string>;
+/** "system" is the "Default" option: it follows the device's light/dark setting. */
+type ThemeMode = "light" | "dark" | "system";
+
+interface ThemeContextValue {
+    /** The brand colour currently applied, or null while the stylesheet defaults are in use. */
+    color: string | null;
+    /** The full 25 to 900 scale currently applied, or null while the defaults are in use. */
+    scale: ThemeScale | null;
+    /**
+     * Applies `hex` as the new primary colour everywhere. Pass `options.scale`
+     * to use an exact, pre-designed scale instead of deriving one from `hex`.
+     * Invalid hex values are ignored.
+     */
+    setThemeColor: (hex: string, options?: {
+        scale?: ThemeScale;
+    }) => void;
+    /** Goes back to `defaultColor` (or the stylesheet defaults) and clears the saved choice. */
+    resetTheme: () => void;
+    /** The user's choice: "light", "dark" or "system" (the "Default" option). */
+    mode: ThemeMode;
+    /** What is actually shown. Differs from `mode` only when `mode` is "system". */
+    resolvedMode: "light" | "dark";
+    /** Changes the mode and remembers it. */
+    setMode: (mode: ThemeMode) => void;
+}
+interface ThemeProviderProps {
+    children: ReactNode;
+    /**
+     * Optional starting brand colour (hex). It is rendered on the server, so
+     * there is no flash. Leave it out to keep the colours from globals.css.
+     */
+    defaultColor?: string;
+    /**
+     * localStorage key used to remember the user's choice. Pass `null` to turn
+     * persistence off. Defaults to "picaso-ui-theme".
+     */
+    storageKey?: string | null;
+    /** CSP nonce for the injected <style> element. */
+    nonce?: string;
+    /**
+     * Starting mode before the user chooses one. Defaults to "system", which
+     * follows the device setting.
+     */
+    defaultMode?: ThemeMode;
+}
+/**
+ * Re-colours every component that uses the `primary` scale.
+ *
+ * Renders no wrapper element, so it does not change the DOM your app already
+ * has. Place it around the existing `theme-primary` container:
+ *
+ * ```tsx
+ * <ThemeProvider>
+ *   <div className="theme-primary">{children}</div>
+ * </ThemeProvider>
+ * ```
+ */
+declare const ThemeProvider: {
+    ({ children, defaultColor, storageKey, nonce, defaultMode, }: ThemeProviderProps): React.JSX.Element;
+    displayName: string;
+};
+declare const useTheme: () => ThemeContextValue;
+
+interface ThemeColorPickerProps extends Omit<ColorPickerProps, "value" | "defaultValue" | "onChange" | "name"> {
+    /** Called after the theme has been updated, with the same arguments as ColorPicker. */
+    onChange?: (value: string, token?: ColorPickerToken) => void;
+    /** Show a "Reset to default" button once the theme has been changed. Defaults to true. */
+    showReset?: boolean;
+}
+/**
+ * A ColorPicker that re-colours the whole library. Everything that uses the
+ * `primary` scale (buttons, inputs, focus rings, tabs, toggles, ...) updates
+ * as soon as a colour is chosen.
+ *
+ * - Choosing a swatch at shade 600 from a family (e.g. Purple 600) applies that
+ *   family's complete, hand-tuned scale.
+ * - Choosing any other swatch, or typing / picking a custom hex, makes that
+ *   colour the main brand colour (`primary-600`) and derives the other shades.
+ *
+ * Must be rendered inside `<ThemeProvider>`.
+ */
+declare const ThemeColorPicker: {
+    ({ onChange, showReset, className, placeholder, ...props }: ThemeColorPickerProps): React.JSX.Element;
+    displayName: string;
+};
+
+interface ThemeModeSwitchProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "children"> {
+    /** Called after the mode has been changed. */
+    onChange?: (mode: ThemeMode) => void;
+    /** Show the text next to each icon. Set to false for a compact, icon-only switch. Defaults to true. */
+    showLabels?: boolean;
+}
+/**
+ * Light / Dark / Default switch. "Default" follows the device setting and
+ * updates live if the device changes. Must be rendered inside `<ThemeProvider>`.
+ */
+declare const ThemeModeSwitch: {
+    ({ onChange, showLabels, className, "aria-label": ariaLabel, ...props }: ThemeModeSwitchProps): React.JSX.Element;
+    displayName: string;
+};
+
+interface ThemeScriptProps {
+    /** Must match `ThemeProvider`'s `defaultMode`. Defaults to "system". */
+    defaultMode?: ThemeMode;
+    /** Must match `ThemeProvider`'s `storageKey`. Defaults to "picaso-ui-theme". Pass `null` if persistence is off. */
+    storageKey?: string | null;
+    /** CSP nonce for the inline script. */
+    nonce?: string;
+}
+/**
+ * Optional. Put it in <head> to apply the saved light/dark mode before the
+ * page paints, so a dark-mode user never sees a white flash on reload.
+ * It is a server component (no hooks, no browser APIs at render time).
+ *
+ * The script changes an attribute on <html> before React hydrates, so add
+ * `suppressHydrationWarning` to your <html> tag.
+ */
+declare const ThemeScript: ({ defaultMode, storageKey, nonce, }: ThemeScriptProps) => React.JSX.Element;
+
+export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Avatar, AvatarGroup, Breadcrumbs as BreadCrumb, Button, Calendar, type CalendarProps, type CalendarRange, Callout, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, Chip, CircularProgressBar as CircularProgress, type ColorFamily, ColorPicker, type ColorPickerProps, type ColorPickerToken, type ColorShade, DatePicker, type DatePickerProps, type DateRange, DateRangePicker, type DateRangePickerProps, type DateRangePreset, DateTimePicker, type DateTimePickerProps, Divider, Drawer, Dropdown, DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, DropdownWithIcon, FileSelector, FileUpload, FileUploadControl, FileUploadPreview, GlobalNavigation, HelperText, Input, Label, ListPagination, Loading, Modal, Notice, OTPInput, Pagination, ProgressBar, Radio, Select, type SelectGroup, type SelectOption, type SelectProps, Sidebar, Skeleton, Slider, Spinner, SplitButton, Stepper, Tab, TabList, TabPanel, Table, TableBody, TableDataCell, TableHead, TableHeadCell, TableRow, TabsContainer, TextInputWithLabel, Textarea, ThemeColorPicker, type ThemeColorPickerProps, type ThemeContextValue, type ThemeMode, ThemeModeSwitch, type ThemeModeSwitchProps, ThemeProvider, type ThemeProviderProps, type ThemeScale, ThemeScript, type ThemeScriptProps, type ThemeShade, TimePicker, type TimePickerProps, Toggle, Tooltip, TreeView, Typography, defaultGetFileIcon, getDefaultRangePresets, useTheme };