import * as react_jsx_runtime from 'react/jsx-runtime';
import * as React$1 from 'react';
import React__default, { ReactNode, FC, HTMLAttributes, ElementType, SVGProps as SVGProps$1, RefObject, Dispatch, SetStateAction, ComponentPropsWithoutRef, ButtonHTMLAttributes, HTMLProps as HTMLProps$1 } from 'react';
import * as Headless from '@headlessui/react';
import { InputProps as InputProps$1, DialogProps, DialogTitleProps, ListboxProps, ListboxOptionProps, FieldProps as FieldProps$1, SwitchProps, TextareaProps as TextareaProps$1, RadioGroup as RadioGroup$1 } from '@headlessui/react';
import * as class_variance_authority_types from 'class-variance-authority/types';
import { VariantProps } from 'class-variance-authority';
import { Placement, UseFloatingReturn, UseInteractionsReturn } from '@floating-ui/react';

declare const _isOptionEqualToValue: <T>(option: T, value: T | T[] | null | undefined) => boolean;
type FnIsOptionEqualToValue<T> = typeof _isOptionEqualToValue<T>;

type RenderOptionProps<T = AutocompleteOptionDefault> = {
    option: T;
    index: number;
    autoHighlight?: boolean;
    getOptionProps: (option: T, index: number) => AutocompleteOptionProps;
} & ({
    getOptionLabel: (option: T) => string;
} | {
    getOptionLabel?: never;
});
declare const _renderOption: <T>({ option, index, autoHighlight, getOptionProps, getOptionLabel, }: RenderOptionProps<T>) => React.ReactNode;
type AutocompleteRenderOption<T> = typeof _renderOption<T>;

type AutocompleteRenderTagsProps<T> = {
    renderableOptions: T[];
    removeSelected?: (option: T) => void;
    getOptionLabel?: (option: T) => string;
    defaultTagProps?: Omit<ChipProps, 'label' | 'onDelete'>;
};
declare const _renderTags: <T>({ renderableOptions, removeSelected, getOptionLabel, defaultTagProps, }: AutocompleteRenderTagsProps<T>) => react_jsx_runtime.JSX.Element[];
type AutocompleteRenderTags<T> = typeof _renderTags<T>;

type AutocompleteOptionDefault = string | {
    label: string;
    disabled?: boolean;
};
type AutocompleteProps<T = AutocompleteOptionDefault> = Omit<InputContainerProps, 'interactionsDisabled' | 'layout' | 'children' | 'endAdornment'> & Pick<InputProps, 'cx'> & {
    /**
     * Placeholder text
     */
    placeholder?: string;
    /**
     * Disable read only
     */
    readOnly?: boolean;
    /**
     * Disable interactions
     */
    disabled?: boolean;
    /**
     * Custom function to compare option and value
     */
    isOptionEqualToValue?: FnIsOptionEqualToValue<T>;
    /**
     * Getter for option disabled state
     */
    getOptionDisabled?: (option: T) => boolean;
    /**
     * Getter for option label
     */
    getOptionLabel?: (option: T) => string;
    /**
     * Component to display list options
     */
    renderOption?: AutocompleteRenderOption<T>;
    /**
     * Component to display list options
     */
    renderSelection?: (option: T) => React.ReactNode;
    /**
     * Component to display selection in `multiple` mode
     */
    renderTags?: AutocompleteRenderTags<T>;
    /**
   * Text to display when the tags are truncated (limitTags).
    Signature:
    function(more: number) => ReactNode
    more: The number of truncated tags.
   */
    getLimitTagsText?: (more: number) => string;
    /**
     * Filter options function
     */
    filterOptions?: (options: T[], filterOptions: AutocompleteFilterOptions) => T[];
    /**
     * List options
     */
    options?: T[];
    /**
     * Close button tooltip text
     */
    textEmpty?: string | null;
    /**
     * Not found text
     */
    textNotFound?: string | null;
    /**
     * Loading icon tooltip text
     */
    textLoading?: string | null;
    /**
     * Clear button tooltip text
     */
    textClear?: string | null;
    /**
     * Create option text
     */
    textCreate?: string | null;
    /**
     * Should highlight matched text
     */
    autoHighlight?: boolean;
    /**
     * Limit of multiple selected to be displayed in input
     */
    limit?: number;
    /**
     * Callback function that is called when creating new option.
     * @param title:string - The new value(s). Calls with the current input value.
     */
    onCreate?: (title: string) => void;
    /**
     * Callback function that is called when the input value changes.
     */
    onInputChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
    /**
     * @default 500
     * either provide a number of pixels or a string like 1rem, 20vh, etc.
     * 'availableHeight': will set the max height of the dropdown to the available height of the screen
     */
    maxHeight?: DropdownMaxHeight;
    /**
     * Props of the default tags component (Chip)
     */
    defaultTagProps?: ChipProps;
    /**
     * z-index configuration
     */
    zIndex?: {
        list?: number;
    };
    /**
     * Should filter selected options from the list
     */
    filterSelectedOptions?: boolean;
} & ({
    /**
     * Current value to display
     */
    value?: T | null;
    /**
     * Allow selection of multiple value
     */
    multiple?: false;
    /**
     * Callback function that is called when the value changes.
     * @param { T |  null } value - The new value(s). Returns an array of selected values. If !multiple, will return an array with one value.
     */
    onChange?: (value: T | null) => void;
} | {
    /**
     * Current value to display
     */
    value?: T[] | null;
    /**
     * Allow selection of multiple value
     */
    multiple: true;
    /**
     * Callback function that is called when the value changes.
     * @param { T[] | null } value - The new value(s). Returns an array of selected values. If !multiple, will return an array with one value.
     */
    onChange?: (value: T[] | null) => void;
});
interface AutocompleteFilterOptionsConfig<T = AutocompleteOptionDefault> {
    ignoreAccents?: boolean;
    ignoreCase?: boolean;
    limit?: number;
    matchFrom: 'start' | 'any' | 'end';
    stringify?: (option: T) => string;
    trim?: boolean;
}
interface AutocompleteFilterOptions<T = any> {
    query: string;
    getOptionLabel: (option: T) => string;
}
type AutocompleteOptionProps = {
    className: string;
    index: number;
    query: string;
    active: boolean;
} & GetItemPropsReturnType;
type GetItemPropsReturnType = {
    'aria-selected'?: boolean;
    'aria-disabled'?: boolean;
    role: string;
    key: string;
    multiple: boolean;
    selected: boolean;
    onClick: (event: React.MouseEvent<HTMLElement>) => void;
    ref: React.RefObject<HTMLLIElement>;
} & React.HTMLProps<HTMLLIElement>;
type AutocompleteInnerInputProps = React.InputHTMLAttributes<HTMLInputElement>;

declare function Autocomplete<T>(props: AutocompleteProps<T>): react_jsx_runtime.JSX.Element;

declare const AVATAR_VARIANTS: readonly ["circle", "rounded", "square"];
type AvatarVariant = (typeof AVATAR_VARIANTS)[number];
type AvatarProps = Omit<React__default.ComponentProps<'img'>, 'size'> & {
    /**
     * How large should the Avatar be?
     */
    size?: number;
    /**
     * Class name
     */
    className?: string;
    /**
     * Variant of Avatar
     */
    variant?: AvatarVariant;
    /**
     * Children of Avatar
     */
    children?: ReactNode;
};

interface AvatarGroupProps extends Pick<AvatarProps, 'size' | 'variant'> {
    /**
     * Total number of avatars to show in counter
     */
    total?: number;
    /**
     * Maximum number of avatars to show
     */
    limit?: number;
    /**
     * Children of AvatarGroup - other `Avatar`s
     */
    children?: ReactNode;
    /**
     * Controls the offset of `Avatar`s components.
     * Default -3.5% which translates directly to margin-left:-3.5%.
     */
    stackingOffsetPercent?: number;
    /**
     * Class name
     */
    className?: string;
    /**
     * `className` for surplus `Avatar` component.
     */
    surplusClassName?: string;
    /**
     * Custom render function for surplus `Avatar` component.
     * @param surplusCount
     * @returns ReactNode
     */
    renderSurplus?: (surplusCount: number) => ReactNode;
}

declare const Avatar: React$1.ForwardRefExoticComponent<Omit<AvatarProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

declare const AvatarGroup: FC<AvatarGroupProps>;

declare const avatarStyles: {
    img: (props?: ({
        variant?: "circle" | "square" | "rounded" | null | undefined;
        container?: boolean | null | undefined;
    } & class_variance_authority_types.ClassProp) | undefined) => string;
    container: string[];
};

/**
 * TODO: Update this component to use your client-side framework's link
 * component. We've provided examples of how to do this for Next.js, Remix, and
 * Inertia.js in the Catalyst documentation:
 *
 * https://catalyst.tailwindui.com/docs#client-side-router-integration
 */

declare const Link: React__default.ForwardRefExoticComponent<{
    href: string;
} & Omit<React__default.DetailedHTMLProps<React__default.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & React__default.RefAttributes<HTMLAnchorElement>>;

type JSXNode = any;
type FunctionalComponent<P = {}> = (props: P) => JSXNode;
type ForwardedComponent<P = {}> = {
    (props: P, ref?: any): JSXNode | null;
};
type HTMLProps<T> = {
    [P in keyof T]?: T[P];
};
type ClassName = string[] | string | undefined;
declare const DATE_TYPES: readonly ["date", "datetime-local", "month", "time", "week"];
type DateType = (typeof DATE_TYPES)[number];
declare const INPUT_TYPES: readonly ["email", "number", "password", "search", "tel", "text", "url", "color", "file"];
type InputType = (typeof INPUT_TYPES)[number];
type HTMLInputType = InputType | DateType;

declare const ELEMENT_COLOR: readonly ["primary", "destructive", "warning", "success", "mono"];
declare const ELEMENT_THEMES: readonly ["dark", "light"];
declare const ELEMENT_BASE_VARIANTS: readonly ["contained", "outlined"];
declare const ELEMENT_VARIANTS: readonly ["contained", "outlined", "text"];
declare const INPUT_VARIANTS: readonly ["contained", "outlined", "underline", "text"];
declare const INPUT_BORDER: readonly ["full", "bottom", "none"];
declare const INPUT_CONTAINER_HEIGHTS: readonly ["fixed", "auto"];
declare const INPUT_BACKGROUNDS: readonly ["none", "bottom", "full"];
declare const ELEMENT_ORIENTATION: readonly ["vertical", "horizontal"];
declare const ELEMENT_PLACEMENT_VERTICAL: readonly ["top", "bottom"];
declare const ELEMENT_PLACEMENT_HORIZONTAL: readonly ["right", "left"];
declare const ELEMENT_POSITION: readonly ["top", "bottom", "right", "left"];
declare const TYPOGRAPHY: readonly ["h1", "h2", "h3", "h4", "h5", "h6", "content", "description"];
declare const TAILWIND_SHADES: readonly [50, 100, 200, 300, 400, 500, 600, 700, 800, 900];
declare const ELEMENT_STATES: readonly ["hover", "focus", "active", "disabled", "default"];
type ElementColor = (typeof ELEMENT_COLOR)[number];
type ElementState = (typeof ELEMENT_STATES)[number];
type ElementOrientation = (typeof ELEMENT_ORIENTATION)[number];
type ElementTheme = (typeof ELEMENT_THEMES)[number];
type ElementVariant = (typeof ELEMENT_VARIANTS)[number];
type InputVariant = (typeof INPUT_VARIANTS)[number];
type InputBorder = (typeof INPUT_BORDER)[number];
type InputContainerHeight = (typeof INPUT_CONTAINER_HEIGHTS)[number];
type InputBackground = (typeof INPUT_BACKGROUNDS)[number];
type ElementBaseVariant = (typeof ELEMENT_BASE_VARIANTS)[number];
type ElementPlacementHorizontal = (typeof ELEMENT_PLACEMENT_HORIZONTAL)[number];
type ElementPlacementVertical = (typeof ELEMENT_PLACEMENT_VERTICAL)[number];
type ElementPosition = (typeof ELEMENT_POSITION)[number];
type ElementTypography = (typeof TYPOGRAPHY)[number];
type ElementPlacement = {
    horizontal: ElementPlacementHorizontal;
    vertical: ElementPlacementVertical;
};
type TailwindShades = (typeof TAILWIND_SHADES)[number];
type TailwindColorSet = Record<TailwindShades, string>;

type DropdownOptionType = {
    id: string;
    label: string;
    disabled?: boolean;
};
type CommitInfo = {
    shortHash: string;
    hash: string;
    subject: string;
    sanitizedSubject: string;
    body: string;
    authoredOn: string;
    committedOn: string;
    author: {
        name: string;
        email: string;
    };
    committer: {
        name: string;
        email: string;
    };
    notes: string;
    branch: string;
    tags: string[];
    version: string;
    timestamp: string;
};
interface MultipleEllipsisFormatter {
    value: string;
    hidden: number;
    total: number;
}
interface UIElement {
    /**
     * Children
     */
    children?: JSXNode;
    /**
     * CSS classes API
     */
    className?: string;
    /**
     * HTML id of element
     */
    id?: string;
}
interface BaseComponentProps {
    /**
     * CSS classes API
     */
    className?: string;
    /**
     * HTML id of element
     */
    id?: string;
    /**
     * Is element required?
     */
    required?: boolean;
    /**
     * Is element read-only?
     */
    readOnly?: boolean;
    /**
     * Input label
     */
    label?: string;
    /**
     * Is disabled?
     */
    disabled?: boolean;
    /**
     * Error message
     */
    error?: JSXNode;
    /**
     * Helper text
     */
    helperText?: JSXNode;
}
interface _InputBaseProps extends Omit<BaseComponentProps, 'className'> {
    /**
     * Component is in loading state?
     */
    loading?: boolean;
    /**
     * Variant of the component?
     */
    variant?: ElementVariant;
    /**
     * Element to be displayed on the left side of the input
     */
    startAdornment?: JSXNode;
    /**
     * Element to be displayed on the right side of the input
     */
    endAdornment?: JSXNode;
    /**
     * Type of HTML input
     */
    type?: HTMLInputType;
    /**
     * Children
     */
    children: JSXNode;
    /**
     * Show clear input icon?
     */
    clearable?: boolean;
    /**
     * Callback for clear input icon.
     */
    onClear?: () => void;
    /**
     * Layout of elements
     */
    layout?: 'column' | 'row';
    /**
     * CSS classes API
     */
    cx?: InputClassNamesAPI;
    /**
     * Disable interactions e.g. while loading, readOnly, disabled. This will prevent interactions with the input by "pointer-events-none".
     */
    interactionsDisabled?: boolean;
    /**
     * Placeholder
     */
    placeholder?: string;
    /**
     * Resize options for textarea
     */
    resize?: 'none' | 'both' | 'horizontal' | 'vertical';
}
type InputClassNamesAPI = {
    container?: {
        outer?: string;
        inner?: string;
    };
    label?: string;
    input?: string;
};
type ReadableError = {
    message: JSXNode;
    title: JSXNode;
    code?: JSXNode;
};
type DropdownValueType = DropdownOptionType | DropdownOptionType[] | string | string[] | null;
type OptionComponentProps = OptionProps & HTMLProps<HTMLLIElement>;
type OptionComponentType = ForwardedComponent<Omit<OptionComponentProps, 'ref'> & {
    ref?: any;
}> | FunctionalComponent<OptionComponentProps>;
type DropdownMaxHeight = number | string | 'available';
interface DropdownProps extends BaseComponentProps {
    /**
     * CSS classes API
     */
    cx?: _InputBaseProps['cx'];
    /**
     * Placeholder
     */
    placeholder?: string | null;
    /**
     * List options
     */
    options?: DropdownOptionType[] | string[];
    /**
     * Component to display list options
     */
    optionComponent?: OptionComponentType;
    /**
     * Component to display list options
     */
    selectedOptionComponent?: FunctionalComponent<SelectedOptionProps>;
    /**
     * Default value to display when component is not controlled
     */
    defaultValue?: DropdownOptionType | string;
    /**
     * Current value to display
     */
    value?: DropdownValueType;
    /**
     * Close button tooltip text
     */
    emptyText?: string | null;
    /**
     * Not found text
     */
    notFoundText?: string | null;
    /**
     * Loading icon tooltip text
     */
    loadingText?: string | null;
    /**
     * Clear button tooltip text
     */
    clearText?: string | null;
    /**
     * Close button tooltip text
     */
    closeText?: string | null;
    /**
     * Should display clear value button
     */
    clearable?: boolean;
    /**
     * Is field required
     */
    required?: boolean;
    /**
     * Is disabled
     */
    disabled?: boolean;
    /**
     * Allow selection of multiple value
     */
    multiple?: boolean;
    /**
     * Should highlight matched text TODO: not implemented
     */
    highlightSearch?: boolean;
    /**
     * Limit of multiple selected to be displayed in input
     */
    limit?: number;
    /**
     * Should display Loader
     */
    loading?: boolean;
    /**
     * Format of count of multiple selected to be displayed in input
     */
    getLimitText?: (more: number) => string;
    /**
     * Filter options function
     */
    filterOptions?: (query?: string) => (option: DropdownOptionType | any) => string;
    /**
     * onChange callback. Will return array of selected values. If !multiple, will return array with one value.
     * @param value
     * @returns
     */
    onChange?: (value: DropdownValueType) => void;
    /**
     * @default 500
     * either provide a number of pixels or a string like 1rem, 20vh, etc.
     * 'availableHeight': will set the max height of the dropdown to the available height of the screen
     */
    maxHeight?: DropdownMaxHeight;
    /**
     * Variant of the input
     */
    variant?: ElementVariant;
    /**
     * z-index configuration
     */
    zIndex?: {
        list?: number;
    };
}
interface OptionProps {
    active: boolean;
    selected?: boolean;
    option: DropdownOptionType;
    multiple?: boolean;
    children?: JSXNode;
}
interface SelectedOptionProps {
    option: DropdownOptionType;
    children?: JSXNode;
    idx: number;
}
type BreadcrumbLink = {
    href: string;
    label: string;
    disabled?: boolean;
};

type ButtonProps = {
    color?: ElementColor | 'unstyled';
    variant?: ElementVariant;
    className?: string;
    children?: ReactNode;
    loading?: boolean;
    disabled?: boolean;
    uppercase?: boolean;
    fullWidth?: boolean;
    startAdornment?: ReactNode;
    endAdornment?: ReactNode;
    spinnerPosition?: ElementPlacementHorizontal;
    loaderColor?: string;
} & (Omit<Headless.ButtonProps, 'className'> | Omit<React__default.ComponentPropsWithoutRef<typeof Link>, 'className'>);
declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLElement>>;

type CalendarDateValue = Date | null | undefined;
type CalendarMode = 'date' | 'range';
type CalendarProps = Omit<BaseComponentProps, 'label' | 'error' | 'helperText' | 'required' | 'disabled' | 'readOnly' | 'loading'> & {
    showTodaySelector?: boolean;
    weekStartsOn?: WeekDayIndex;
    todayText?: string;
    startOn?: CalendarDateValue;
    numberOfMonths?: 1 | 2;
    locale?: string;
} & ({
    onChange?: (date: CalendarDateValue) => void;
    value?: CalendarDateValue;
    mode?: 'date';
} | {
    onChange?: (date: DateRange) => void;
    value?: DateRange;
    mode?: 'range';
});
type DateRange = [CalendarDateValue, CalendarDateValue];
type CalendarViewMode = 'days' | 'months' | 'years';
type WeekDayIndex = 1 | 2 | 3 | 4 | 5 | 6 | 7;

declare const Calendar: FC<CalendarProps>;

interface CardProps extends HTMLAttributes<HTMLDivElement> {
    href?: string;
}

declare const CardTitle: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLHeadingElement> & React__default.RefAttributes<HTMLHeadingElement>>;
declare const Card: React__default.ForwardRefExoticComponent<CardProps & React__default.RefAttributes<HTMLDivElement>>;

declare const CardContent: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
declare const CardDescription: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLParagraphElement> & React__default.RefAttributes<HTMLParagraphElement>>;
declare const CardFooter: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
declare const CardHeader: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
declare const CardStats: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;

declare const CardStyles: (props?: ({} & class_variance_authority_types.ClassProp) | undefined) => string;

interface CheckboxProps extends Omit<Headless.CheckboxProps, 'as' | 'className'> {
    children?: ReactNode;
    className?: string;
    readOnly?: boolean;
    loading?: boolean;
}

declare const Checkbox: FC<CheckboxProps>;

declare const checkboxStyles: (props?: ({
    readOnly?: boolean | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;

type ChipProps = Partial<Pick<BaseComponentProps, 'label'>> & {
    /**
     * Should be uppercase?
     */
    uppercase?: boolean;
    /**
     * Status of the element
     */
    color?: ElementColor | 'unstyled';
    /**
     * Should have border?
     */
    border?: boolean;
    /**
     * Variant
     */
    variant?: ElementBaseVariant;
    /**
     * Start adornment
     */
    startAdornment?: ReactNode;
    /**
     * Start adornment
     */
    endAdornment?: ReactNode;
    /**
     * Callback when delete button is clicked
     */
    onDelete?: () => void;
    /**
     *
     * Callback when chip is clicked
     */
    onClick?: () => void;
    /**
     * Class names overrides
     */
    cx?: Pick<InputClassNamesAPI, 'container'>;
    /**
     * Style overrides, helpful with adding custom colors. Passing `style` will disable `color` prop.
     */
    style?: React.CSSProperties;
};

declare const Chip: {
    (props: ChipProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const chipClasses: (props?: ({
    uppercase?: boolean | null | undefined;
    interactive?: boolean | null | undefined;
    variant?: "text" | "contained" | "outlined" | null | undefined;
    color?: "primary" | "destructive" | "warning" | "success" | "mono" | "unstyled" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;

interface ClearButtonProps {
    onClick?: (e: React.MouseEvent<HTMLElement>) => void;
    className?: string;
}
declare const ClearButton: React$1.ForwardRefExoticComponent<ClearButtonProps & React$1.RefAttributes<HTMLElement>>;

interface Circle {
    r: number;
}
interface Mask {
    cx: string;
    cy: string;
}
interface Svg {
    transform: string;
}
interface Lines {
    opacity: number;
}
interface Dark {
    circle: Circle;
    mask: Mask;
    svg: Svg;
    lines: Lines;
}
interface Circle2 {
    r: number;
}
interface Mask2 {
    cx: string;
    cy: string;
}
interface Svg2 {
    transform: string;
}
interface Lines2 {
    opacity: number;
}
interface Light {
    circle: Circle2;
    mask: Mask2;
    svg: Svg2;
    lines: Lines2;
}
interface SpringConfig {
    mass: number;
    tension: number;
    friction: number;
}
interface AnimationProperties {
    dark: Dark;
    light: Light;
    springConfig: SpringConfig;
}
type SVGProps = Omit<React.HTMLAttributes<HTMLOrSVGElement>, 'onChange'>;
interface DarkModeToggleProps extends SVGProps {
    onModeChange?: (theme: ElementTheme) => void;
    theme?: ElementTheme;
    style?: React.CSSProperties;
    size?: number | string;
    animationProperties?: AnimationProperties;
    moonColor?: string;
    sunColor?: string;
    defaultTheme?: ElementTheme;
    localStorageKey?: string;
}

declare const DarkModeToggle: FC<DarkModeToggleProps>;

declare const Input: React__default.NamedExoticComponent<Omit<Headless.InputProps, "as"> & {
    as?: React__default.ElementType;
    endAdornment?: React__default.ReactNode;
    startAdornment?: React__default.ReactNode;
    onClear?: () => void;
    type?: HTMLInputType;
    cx?: {
        container?: string;
        input?: string;
    };
} & Omit<InputContainerProps, "className" | "clearable"> & React__default.RefAttributes<HTMLInputElement>>;

declare function InputGroup({ children, }: React.ComponentPropsWithoutRef<'span'>): react_jsx_runtime.JSX.Element;

declare const cuiInputContainer: (props?: ({
    containerHeight?: "fixed" | "auto" | null | undefined;
    isDateType?: boolean | null | undefined;
    adornments?: boolean | "both" | "end" | "start" | null | undefined;
    clearable?: boolean | null | undefined;
    inputType?: "default" | "color" | "file" | null | undefined;
    border?: "bottom" | "full" | "none" | null | undefined;
    background?: boolean | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
type InputContainerStyles = VariantProps<typeof cuiInputContainer>;

declare const InputContainer: React$1.NamedExoticComponent<Pick<React$1.HTMLAttributes<HTMLDivElement>, "className" | "children" | "style" | "onClick"> & Omit<InputContainerStyles, "clearable" | "adornments"> & {
    endAdornment?: React.ReactNode;
    startAdornment?: React.ReactNode;
    onClear?: () => void;
    disabled?: boolean;
    readOnly?: boolean;
    hasValue?: boolean;
} & React$1.RefAttributes<HTMLDivElement>>;

interface EndAdornmentProps {
    children: ReactNode;
    className?: string;
}
declare const EndAdornment: ({ children, className }: EndAdornmentProps) => react_jsx_runtime.JSX.Element;

interface StartAdornmentProps {
    children: ReactNode;
    className?: string;
}
declare const StartAdornment: ({ children, className, }: StartAdornmentProps) => react_jsx_runtime.JSX.Element;

type InputContainerProps = Pick<React.HTMLAttributes<HTMLDivElement>, 'className' | 'style' | 'children' | 'onClick'> & Omit<InputContainerStyles, 'adornments' | 'clearable'> & {
    endAdornment?: React.ReactNode;
    startAdornment?: React.ReactNode;
    onClear?: () => void;
    disabled?: boolean;
    readOnly?: boolean;
    hasValue?: boolean;
};

type InputProps = Omit<InputProps$1, 'as'> & {
    as?: ElementType;
    endAdornment?: ReactNode;
    startAdornment?: ReactNode;
    onClear?: () => void;
    type?: HTMLInputType;
    cx?: {
        container?: string;
        input?: string;
    };
} & Omit<InputContainerProps, 'className' | 'clearable'>;

type DatePickerProps = Omit<CalendarProps, 'onChange'> & Omit<InputProps, 'onChange' | 'value' | 'ref'> & {
    onChange?: (date: CalendarDateValue) => void;
    /**
     * z-index configuration
     */
    zIndex?: {
        popover?: number;
    };
};

declare const DatePicker: FC<DatePickerProps>;

interface DescriptionProps extends Omit<Headless.DescriptionProps, 'as' | 'className'> {
    children?: ReactNode;
    className?: string;
}

declare const Description: FC<DescriptionProps>;

declare const DescriptionStyles: (props?: ({} & class_variance_authority_types.ClassProp) | undefined) => string;

interface DrawerProps {
    /**
     * The content of the drawer.
     */
    children?: ReactNode;
    /**
     * The position of the drawer. `right` | `left` | `top` | `bottom`
     * @default `right``
     */
    position?: ElementPosition;
    /**
     * Whether the drawer is open or not. `true` | `false`
     * @default `false`
     */
    open?: boolean;
    /**
     * Callback for when the drawer is closed.
     * @default `() => {}`
     */
    onClose?: () => void;
    /**
     *
     * Callback for when the overlay is clicked.
     */
    onOverlayClick?: () => void;
    /**
     * Class names API
     */
    cx?: {
        /**
         * Set height of the drawer
         */
        height?: string;
        /**
         * Set width of the drawer
         */
        width?: string;
        container?: {
            /**
             * Manipulate the outer container element
             */
            outer?: string;
            /**
             * Manipulate the inner container element, e.g. add margins and roundness.
             */
            inner?: string;
        };
    };
}

declare const Drawer: ({ open, children, onOverlayClick, ...props }: DrawerProps) => react_jsx_runtime.JSX.Element;

declare const drawerAnimation: {
    animation: string[];
    enter: {
        top: string[];
        bottom: string[];
        right: string[];
        left: string[];
    };
    leave: {
        top: string[];
        bottom: string[];
        right: string[];
        left: string[];
    };
};
declare const drawerChildClasses: string[];
declare const drawerStyles: (props?: ({
    position?: "top" | "bottom" | "right" | "left" | null | undefined;
    defaultVariants?: "position" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;

declare const Icon: ({ icon, title, className, ...props }: IconProps) => react_jsx_runtime.JSX.Element;

declare const icons: string[];
type IconType = (typeof icons)[number];
interface IconProps extends Omit<SVGProps$1<SVGSVGElement>, 'className' | 'children'> {
    /**
     * Icon name from Material Icons collection
     */
    icon: IconType;
    /**
     * Additional class names
     */
    className?: ClassName;
    /**
     * Title for the icon
     */
    title?: string;
}

interface DropdownChevronProps extends Omit<IconProps, 'icon'> {
    /**
     * Open state
     */
    open?: boolean;
    /**
     * Disabled state
     */
    disabled?: boolean;
}

declare const DropdownChevron: ({ open, className, disabled, ...props }: DropdownChevronProps) => react_jsx_runtime.JSX.Element;

declare const DropdownChevronStyles: (props?: ({} & class_variance_authority_types.ClassProp) | undefined) => string;

interface ErrorProps extends Omit<Headless.DescriptionProps, 'as' | 'className'> {
    children?: ReactNode;
    className?: string;
}

declare const Error: FC<ErrorProps>;

declare const fieldStyles: (props?: ({
    layout?: "column" | "row" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
type FieldLayout = VariantProps<typeof fieldStyles>['layout'];

interface FieldProps extends Omit<Headless.FieldProps, 'as' | 'className'> {
    children?: ReactNode;
    className?: string;
    layout?: FieldLayout;
}

declare const Field: FC<FieldProps>;

declare const flexClasses: (props?: ({
    column?: boolean | null | undefined;
    justify?: "end" | "start" | "center" | "between" | "around" | "evenly" | null | undefined;
    items?: "end" | "start" | "center" | "stretch" | "baseline" | null | undefined;
    self?: "auto" | "end" | "start" | "center" | "stretch" | "baseline" | null | undefined;
    wrap?: "none" | "reverse" | "wrap" | null | undefined;
    content?: "end" | "start" | "center" | "between" | "around" | "evenly" | null | undefined;
    gapX?: 0 | 1 | 5 | 9 | 2 | 3 | 4 | 8 | 10 | 6 | 32 | 40 | 7 | 12 | 11 | 14 | 16 | 20 | 24 | 28 | 36 | 44 | 48 | 52 | 56 | 60 | 64 | 72 | 80 | 96 | null | undefined;
    gapY?: 0 | 1 | 5 | 9 | 2 | 3 | 4 | 8 | 10 | 6 | 32 | 40 | 7 | 12 | 11 | 14 | 16 | 20 | 24 | 28 | 36 | 44 | 48 | 52 | 56 | 60 | 64 | 72 | 80 | 96 | null | undefined;
    grow?: boolean | null | undefined;
    shrink?: boolean | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;

type FlexClasses = VariantProps<typeof flexClasses>;
type FlexProps = FlexClasses & Pick<React.HTMLAttributes<HTMLDivElement>, 'title' | 'className' | 'children' | 'onClick'>;

declare const Flex: FC<FlexProps>;

interface ForProps<T = any[]> {
    each?: T[];
    children?: (item: T, index: number) => ReactNode;
}

declare const For: <T>(props: ForProps<T>) => ReactNode;

interface HighlighterProps {
    searchWords: string[];
    textToHighlight: string;
}

declare const Highlighter: FC<HighlighterProps>;

declare const HighlighterStyles: (props?: ({} & class_variance_authority_types.ClassProp) | undefined) => string;

declare const _default: (_locked?: boolean, _elementRef?: RefObject<HTMLElement>) => void;

type parserOptions<T> = {
    raw: boolean;
    serializer?: (value: T) => string;
    deserializer?: (value: string) => T;
};
declare const useLocalStorage: <T>(key: string, initialValue?: T, options?: parserOptions<T>) => [T | undefined, Dispatch<SetStateAction<T | undefined>>, () => void];

interface ContentRect {
    width: number;
    height: number;
    top: number;
    right: number;
    left: number;
    bottom: number;
}
declare const useMeasureDirty: (ref: RefObject<HTMLElement>) => ContentRect;

/**
 * Use this hook to detect whether dark mode is active based on the presence of the 'dark' class on the body element.
 * @returns {boolean} - Returns true if dark mode is active, otherwise false.
 */
declare function useDetectDarkMode(): boolean;

interface LabelProps extends Omit<Headless.LabelProps, 'as' | 'className'> {
    children?: ReactNode;
    className?: string;
    required?: boolean;
}

declare const Label: FC<LabelProps>;

declare const labelStyles: (props?: ({
    required?: boolean | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;

type LoaderProps = {
    /**
     * Color of the loader
     */
    color?: string | ElementColor;
    /**
     * Class names API. Inner will be applied to SVG element, outer to the container.
     */
    cx?: {
        outer?: string;
        inner?: string;
    };
};

declare const Loader: (props: LoaderProps) => react_jsx_runtime.JSX.Element;

interface OverlayProps {
    active?: boolean;
    onClick?: () => void;
    className?: string;
    cursorWait?: boolean;
    children?: ReactNode;
}

declare const Overlay: FC<OverlayProps>;

declare const overlay: (props?: ({
    cursorWait?: boolean | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;

interface LoadingOverlayProps extends Partial<Omit<OverlayProps, 'className'>> {
    cx?: {
        overlay?: string;
        loader?: LoaderProps['cx'];
    };
    /**
     * Loader color
     */
    loaderColor?: LoaderProps['color'];
}

declare const LoadingOverlay: ({ cx, ...props }: LoadingOverlayProps) => react_jsx_runtime.JSX.Element;

declare const LoadingOverlayStyles: (props?: ({} & class_variance_authority_types.ClassProp) | undefined) => string;

type ModalProps = {
    className?: string;
    children: React.ReactNode;
} & Omit<DialogProps, 'as' | 'className'>;
type ModalHeaderProps = {
    className?: string;
    border?: boolean;
} & Omit<DialogTitleProps, 'as' | 'className'>;
type ModalBodyProps = ComponentPropsWithoutRef<'div'>;
type ModalFooterProps = {
    border?: boolean;
} & ComponentPropsWithoutRef<'div'>;

declare const Modal: FC<ModalProps>;
declare const ModalHeader: FC<ModalHeaderProps>;
declare const ModalBody: FC<ModalBodyProps>;
declare const ModalFooter: FC<ModalFooterProps>;

declare const ModalStyles: (props?: ({} & class_variance_authority_types.ClassProp) | undefined) => string;

interface PopoverOptions {
    initialOpen?: boolean;
    placement?: Placement;
    modal?: boolean;
    open?: boolean;
    onOpenChange?: (open: boolean) => void;
    className?: string;
}

type PopoverContextType = ReturnType<typeof usePopover> | null;
declare function usePopover({ initialOpen, placement, modal, open: controlledOpen, onOpenChange: setControlledOpen, }?: PopoverOptions): UseFloatingReturn & UseInteractionsReturn & {
    open: boolean;
    setOpen: (open: boolean) => void;
    modal?: boolean;
    labelId?: string;
    descriptionId?: string;
    setLabelId: (id: string | undefined) => void;
    setDescriptionId: (id: string | undefined) => void;
};

declare const PopoverContext: React$1.Context<PopoverContextType>;
declare const usePopoverContext: () => NonNullable<PopoverContextType>;

interface PopoverCloseProps extends ButtonHTMLAttributes<HTMLButtonElement> {
}
declare const PopoverClose: React$1.ForwardRefExoticComponent<PopoverCloseProps & React$1.RefAttributes<HTMLButtonElement>>;

interface PopoverContentProps extends Omit<HTMLProps$1<HTMLDivElement>, 'size'> {
    zIndex?: number;
}
declare const PopoverContent: React$1.ForwardRefExoticComponent<Omit<PopoverContentProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

interface PopoverDescriptionProps extends Omit<HTMLProps$1<HTMLParagraphElement>, 'size'> {
}
declare const PopoverDescription: React$1.ForwardRefExoticComponent<Omit<HTMLProps$1<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;

interface PopoverHeadingProps extends Omit<HTMLProps$1<HTMLHeadingElement>, 'size'> {
}
declare const PopoverHeading: React$1.ForwardRefExoticComponent<Omit<PopoverHeadingProps, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;

declare function Popover({ children, modal, className, ...restOptions }: {
    children: ReactNode;
} & PopoverOptions): react_jsx_runtime.JSX.Element;

interface PopoverTriggerProps extends Omit<HTMLProps$1<HTMLElement>, 'size'> {
    children: ReactNode;
    asChild?: boolean;
}
declare const PopoverTrigger: React__default.ForwardRefExoticComponent<Omit<PopoverTriggerProps, "ref"> & React__default.RefAttributes<HTMLElement>>;

interface RadioProps extends Omit<Headless.RadioProps, 'as' | 'className' | 'children'> {
    className?: string;
}
interface RadioGroupProps extends Omit<Headless.RadioGroupProps, 'as' | 'className'> {
    className?: string;
    readOnly?: boolean;
}

declare const Radio: FC<RadioProps>;

declare const radioGroupStyles: (props?: ({} & class_variance_authority_types.ClassProp) | undefined) => string;
declare const radioStyles: (props?: ({} & class_variance_authority_types.ClassProp) | undefined) => string;

declare const RadioGroup: FC<RadioGroupProps>;

type SelectProps<T = string> = Omit<ListboxProps, 'as' | 'className' | 'multiple' | 'value'> & Omit<InputContainerProps, 'className' | 'onClear'> & Pick<InputProps, 'cx'> & {
    readOnly?: boolean;
    value?: T | null;
};
type SelectHOC<T> = {
    open: boolean;
    disabled: boolean;
    invalid: boolean;
    value: T | null;
};

interface SelectComponentProps<T = string> extends SelectProps<T> {
    /**
     * Children to render
     */
    children: ReactNode;
    /**
     * Callback when clear button is clicked
     */
    onClear?: () => void;
}
declare const Select: React__default.ForwardRefExoticComponent<SelectComponentProps<unknown> & React__default.RefAttributes<HTMLDivElement>>;

interface SelectButtonProps {
    children?: ReactNode;
    className?: string;
}
declare const SelectButton: React$1.ForwardRefExoticComponent<SelectButtonProps & React$1.RefAttributes<HTMLButtonElement>>;

interface SelectedProps {
    placeholder?: string;
    formatter?: (value: any) => string;
    children?: ReactNode;
    className?: string;
}
declare const Selected: React$1.ForwardRefExoticComponent<SelectedProps & React$1.RefAttributes<HTMLSpanElement>>;

interface SelectOptionProps extends Omit<ListboxOptionProps, 'selected'> {
    children?: ReactNode;
    className?: string;
    multiple?: boolean;
    truncate?: boolean;
    showCheckIcon?: boolean;
}
declare const SelectOption: React$1.ForwardRefExoticComponent<SelectOptionProps & React$1.RefAttributes<HTMLLIElement>>;

declare const zIndexStyles: (props?: ({
    zIndex?: "dropdown" | "tooltip" | "overlay" | "drawer" | "modal" | "notification" | "default" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
type ZIndex = VariantProps<typeof zIndexStyles>['zIndex'];

interface SelectOptionsProps {
    children?: ReactNode;
    className?: string;
    zIndex?: ZIndex;
}
declare const SelectOptions: React$1.ForwardRefExoticComponent<SelectOptionsProps & React$1.RefAttributes<HTMLUListElement>>;

interface SelectContextValue<T = string> {
    open: boolean;
    disabled: boolean;
    invalid: boolean;
    value: T;
    onClear?: () => void;
}
declare const SelectContext: React$1.Context<SelectContextValue<string> | null>;
declare const useSelectContext: () => SelectContextValue<string>;

declare const getDropdownHeight: (maxHeight: DropdownMaxHeight | undefined, availableHeight: number) => string;

interface PlaceholderProps {
    children: React.ReactNode;
}
declare const Placeholder: FC<PlaceholderProps>;

declare const dropdownMenuClasses: (props?: ({
    open?: boolean | null | undefined;
    placement?: "top" | "bottom" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
type DropdownMenudStyles = VariantProps<typeof dropdownMenuClasses>;
interface DropdownMenuProps extends React.HTMLProps<HTMLUListElement> {
    open?: boolean;
    placement?: DropdownMenudStyles['placement'];
    zIndex?: ZIndex;
}
declare const DropdownMenu: React$1.ForwardRefExoticComponent<Omit<DropdownMenuProps, "ref"> & React$1.RefAttributes<HTMLUListElement>>;

interface ShowProps {
    when?: boolean;
    children?: React.ReactNode;
    fallback?: React.ReactNode;
}
type ShowFirstMatchingProps = {
    children: React.ReactElement<ShowProps>[] | React.ReactElement<ShowProps>;
    fallback?: React.ReactNode;
};

declare const Show: ({ when, children, fallback }: ShowProps) => react_jsx_runtime.JSX.Element;

/**
 * Render a field wrapper for a switch control that arranges control, label, and description using slot-based layout.
 *
 * The component forwards all remaining FieldProps to the underlying Headless UI Field, applies a grid-based layout,
 * and merges the provided `className` with the component's slot-aware layout classes.
 *
 * @param className - Optional additional class names applied to the root field container.
 * @param props - Remaining FieldProps forwarded to the underlying HeadlessField.
 *
 * @returns A HeadlessField element configured for a switch control with slot-aware styling.
 *
 * @example
 * <SwitchField>
 *   <SwitchField.Label slot="label">Enable feature</SwitchField.Label>
 *   <SwitchField.Control slot="control">
 *     <Switch ... />
 *   </SwitchField.Control>
 *   <SwitchField.Description slot="description">Toggles the feature on or off.</SwitchField.Description>
 * </SwitchField>
 *
 * @remarks
 * - Accessibility: Provide a label (slot="label") and, when needed, a description (slot="description") so assistive technologies can associate the switch control correctly.
 */
declare function SwitchField({ className, ...props }: {
    className?: string;
} & Omit<FieldProps$1, 'as' | 'className'>): react_jsx_runtime.JSX.Element;
/**
 * Renders a styled toggle switch control with a visible knob.
 *
 * The component forwards all SwitchProps to the underlying Headless UI Switch, merges provided
 * class names with the component's default styles, and renders a non-interactive span as the
 * visual knob.
 *
 * @param className - Optional additional class names applied to the switch container.
 * @param props - Remaining SwitchProps forwarded to the underlying Headless UI Switch.
 * @returns The rendered Headless UI Switch element containing a styled, aria-hidden knob.
 *
 * @example
 * <Switch checked={enabled} onChange={setEnabled} />
 *
 * @accessibility
 * The component forwards ARIA attributes and state from Headless UI. Provide `checked` and
 * `onChange` to expose the switch state to assistive technologies; the inner knob is marked
 * `aria-hidden="true"` because it is purely decorative.
 */
declare function Switch({ className, ...props }: {
    className?: string;
} & Omit<SwitchProps, 'as' | 'className' | 'children'>): react_jsx_runtime.JSX.Element;

interface TextareaProps extends Omit<TextareaProps$1, 'as' | 'className'> {
    className?: string;
    resizable?: boolean;
}

declare const Textarea: React__default.ForwardRefExoticComponent<TextareaProps & React__default.RefAttributes<HTMLTextAreaElement>>;

declare const TextareaStyles: (props?: ({} & class_variance_authority_types.ClassProp) | undefined) => string;
declare const containerClasses: string[];

type GetComponentProps<T> = T extends React.ComponentType<infer P> | React.Component<infer P> ? P : never;
type HeadlessRadioGroupOptionProps = GetComponentProps<typeof RadioGroup$1.Option>;
type HeadlessRadioGroupProps = GetComponentProps<typeof RadioGroup$1>;
type ToggleGroupValue = string;
type ToggleGroupOption = HeadlessRadioGroupOptionProps & {
    label: string | React.ReactNode;
    value: ToggleGroupValue;
    disabled?: boolean;
};
type ToggleGroupProps = Omit<RadioGroupProps, 'readonly' | 'label' | 'required' | 'onChange' | 'value'> & {
    options: ToggleGroupOption[];
    value?: ToggleGroupValue;
    onChange?: (value: ToggleGroupValue) => void;
};

/**
 *
 * <ToggleGroup>
 *  <ToggleOption>
 *  <ToggleOption>
 *  <ToggleOption>
 *  <ToggleOption>
 * </ToggleGroup>
 */
declare const ToggleGroup: ({ className, options, onChange, value, disabled, ...props }: ToggleGroupProps) => react_jsx_runtime.JSX.Element;

declare const toggleGroupButtonStyles: (props?: ({
    element?: "middle" | "first" | "last" | null | undefined;
    checked?: boolean | null | undefined;
    disabled?: boolean | null | undefined;
    autofocus?: boolean | null | undefined;
    focus?: boolean | null | undefined;
    hover?: boolean | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
declare const toggleGroupContainerStyles: (props?: ({
    disabled?: boolean | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;

interface TooltipProps {
    className?: string;
    children?: React.ReactNode;
    content?: React.ReactNode;
    position?: ElementPosition;
}

declare const Tooltip: (props: TooltipProps) => string | number | bigint | boolean | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;

interface TouchTargetProps {
    children?: ReactNode;
    disabled?: boolean;
}
/**
 * Expand the hit area to at least 44×44px on touch devices
 */
declare function TouchTarget({ children, disabled }: TouchTargetProps): react_jsx_runtime.JSX.Element;

declare function propsGuard<T extends Record<string, any>>(propsList: string[], props: T): T;

declare const getWidthClasses: (classes: string[]) => string[];

/**
 *
 * Curried function to merge base element classes with incoming `props.className`
 * @param classes base element classes
 * @returns `(className?: string | string[]) => string`
 * @example
 * const baseClasses = twix(['text-red-500', 'text-center'])
 * <div className={baseClasses(props.className)} />
 */
declare const twix: (...classes: string[]) => (className?: string | string[]) => string;

declare const pick: <T, K extends keyof T>(obj: T, keys: K[]) => Pick<T, K>;

/**
 * Checks if a value is present (not null or undefined).
 *
 * This utility is specifically designed for form field validation where
 * falsy values like 0, '', and false are considered valid selections,
 * but null and undefined represent the absence of a value.
 *
 * Unlike a simple truthiness check (!!value), this function treats
 * all non-nullish values as "having a value", which is crucial for
 * form controls that can legitimately have falsy but meaningful values.
 *
 * @param value - The value to check for presence
 * @returns true if value is not null and not undefined, false otherwise
 *
 * @example
 * ```typescript
 * isNonNulish(0)         // true  - zero is a valid value
 * isNonNulish('')        // true  - empty string is a valid value
 * isNonNulish(false)     // true  - false is a valid boolean value
 * isNonNulish(null)      // false - null represents no value
 * isNonNulish(undefined) // false - undefined represents no value
 * isNonNulish('hello')   // true  - non-empty string has value
 * isNonNulish([])        // true  - empty array still has value (it's an array)
 * isNonNulish({})        // true  - empty object still has value (it's an object)
 * ```
 */
declare const isNonNulish: <T>(value: T) => value is NonNullable<T>;

declare const noop: () => void;
declare const passThrough: (...args: any) => any;
declare function on<T extends Window | Document | HTMLElement | EventTarget>(obj: T | null, ...args: Parameters<T['addEventListener']> | [string, Function | null, ...any]): void;
declare function off<T extends Window | Document | HTMLElement | EventTarget>(obj: T | null, ...args: Parameters<T['removeEventListener']> | [string, Function | null, ...any]): void;
declare const isBrowser: boolean;
declare const isNavigator: boolean;

export { AVATAR_VARIANTS, type AnimationProperties, Autocomplete, type AutocompleteFilterOptions, type AutocompleteFilterOptionsConfig, type AutocompleteInnerInputProps, type AutocompleteOptionDefault, type AutocompleteOptionProps, type AutocompleteProps, type AutocompleteRenderOption, type AutocompleteRenderTags, type AutocompleteRenderTagsProps, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarVariant, type BaseComponentProps, type BreadcrumbLink, Button, type ButtonProps, Calendar, type CalendarDateValue, type CalendarMode, type CalendarProps, type CalendarViewMode, Card, CardContent, CardDescription, CardFooter, CardHeader, type CardProps, CardStats, CardStyles, CardTitle, Checkbox, type CheckboxProps, Chip, type ChipProps, type Circle, type Circle2, type ClassName, ClearButton, type ClearButtonProps, type CommitInfo, DATE_TYPES, type Dark, DarkModeToggle, type DarkModeToggleProps, DatePicker, type DatePickerProps, type DateRange, type DateType, Description, type DescriptionProps, DescriptionStyles, Drawer, type DrawerProps, DropdownChevron, type DropdownChevronProps, DropdownChevronStyles, type DropdownMaxHeight, DropdownMenu, type DropdownMenuProps, type DropdownOptionType, type DropdownProps, type DropdownValueType, ELEMENT_BASE_VARIANTS, ELEMENT_COLOR, ELEMENT_ORIENTATION, ELEMENT_PLACEMENT_HORIZONTAL, ELEMENT_PLACEMENT_VERTICAL, ELEMENT_POSITION, ELEMENT_STATES, ELEMENT_THEMES, ELEMENT_VARIANTS, type ElementBaseVariant, type ElementColor, type ElementOrientation, type ElementPlacement, type ElementPlacementHorizontal, type ElementPlacementVertical, type ElementPosition, type ElementState, type ElementTheme, type ElementTypography, type ElementVariant, EndAdornment, Error, type ErrorProps, Field, type FieldLayout, type FieldProps, Flex, type FlexClasses, type FlexProps, For, type ForProps, type ForwardedComponent, type FunctionalComponent, type GetComponentProps, type GetItemPropsReturnType, type HTMLInputType, type HTMLProps, type HeadlessRadioGroupOptionProps, type HeadlessRadioGroupProps, Highlighter, type HighlighterProps, HighlighterStyles, INPUT_BACKGROUNDS, INPUT_BORDER, INPUT_CONTAINER_HEIGHTS, INPUT_TYPES, INPUT_VARIANTS, Icon, type IconProps, type IconType, Input, type InputBackground, type InputBorder, type InputClassNamesAPI, InputContainer, type InputContainerHeight, type InputContainerProps, type InputContainerStyles, InputGroup, type InputProps, type InputType, type InputVariant, type JSXNode, Label, type LabelProps, type Light, type Lines, type Lines2, Link, Loader, type LoaderProps, LoadingOverlay, type LoadingOverlayProps, LoadingOverlayStyles, type Mask, type Mask2, Modal, ModalBody, type ModalBodyProps, ModalFooter, type ModalFooterProps, ModalHeader, type ModalHeaderProps, type ModalProps, ModalStyles, type MultipleEllipsisFormatter, type OptionComponentProps, type OptionComponentType, type OptionProps, Overlay, type OverlayProps, Placeholder, Popover, PopoverClose, PopoverContent, PopoverContext, type PopoverContextType, PopoverDescription, type PopoverDescriptionProps, PopoverHeading, type PopoverOptions, PopoverTrigger, Radio, RadioGroup, type RadioGroupProps, type RadioProps, type ReadableError, type SVGProps, Select, SelectButton, SelectContext, type SelectContextValue, type SelectHOC, SelectOption, SelectOptions, type SelectProps, Selected, type SelectedOptionProps, Show, type ShowFirstMatchingProps, type ShowProps, type SpringConfig, StartAdornment, type Svg, type Svg2, Switch, SwitchField, TAILWIND_SHADES, TYPOGRAPHY, type TailwindColorSet, type TailwindShades, Textarea, type TextareaProps, TextareaStyles, ToggleGroup, type ToggleGroupOption, type ToggleGroupProps, type ToggleGroupValue, Tooltip, type TooltipProps, TouchTarget, type UIElement, type WeekDayIndex, type _InputBaseProps, _renderOption, _renderTags, avatarStyles, checkboxStyles, chipClasses, containerClasses, cuiInputContainer, drawerAnimation, drawerChildClasses, drawerStyles, dropdownMenuClasses, fieldStyles, flexClasses, getDropdownHeight, getWidthClasses, icons, isBrowser, isNavigator, isNonNulish, labelStyles, noop, off, on, overlay, passThrough, pick, propsGuard, radioGroupStyles, radioStyles, toggleGroupButtonStyles, toggleGroupContainerStyles, twix, useDetectDarkMode, useLocalStorage, _default as useLockScroll, useMeasureDirty, usePopover, usePopoverContext, useSelectContext };