@socprime/react-ui 0.0.5

package/index.d.ts

@@ -0,0 +1,702 @@
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
+import * as React$1 from 'react';
+import React__default, { ComponentProps, FC } from 'react';
+import { LucideIcon, LucideProps } from 'lucide-react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { LinkProps } from 'react-router-dom';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import { Root, Item } from '@radix-ui/react-radio-group';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import { Separator as Separator$1 } from '@radix-ui/react-separator';
+import * as SliderPrimitive from '@radix-ui/react-slider';
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+import { ToasterProps } from 'sonner';
+export { ToasterProps } from 'sonner';
+export { T as ThemeName, a as applyTheme, u as useDocumentTheme } from './theme-9m7j1UoI.js';
+import { RowData, Table as Table$1, Header, ColumnDef } from '@tanstack/react-table';
+
+type AccordionChevronVariant = 'down' | 'section' | 'tree' | 'tree-sm' | 'none';
+
+type AccordionProps = React$1.ComponentProps<typeof AccordionPrimitive.Root>;
+type AccordionItemProps = React$1.ComponentProps<typeof AccordionPrimitive.Item>;
+type AccordionTriggerProps = React$1.ComponentProps<typeof AccordionPrimitive.Trigger> & {
+    chevronPosition?: 'left' | 'right';
+    chevronVariant?: AccordionChevronVariant;
+};
+type AccordionContentProps = React$1.ComponentProps<typeof AccordionPrimitive.Content>;
+declare const Accordion: React$1.FC<AccordionProps>;
+declare const AccordionItem: React$1.FC<AccordionItemProps>;
+declare const AccordionTrigger: React$1.FC<AccordionTriggerProps>;
+declare const AccordionContent: React$1.FC<AccordionContentProps>;
+
+type AccordionSectionProps = {
+    value: string;
+    title: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    children: React$1.ReactNode;
+    itemClassName?: string;
+    triggerClassName?: string;
+    contentClassName?: string;
+};
+declare const AccordionSection: React$1.FC<AccordionSectionProps>;
+
+type FolderTreeExpandTriggerProps = Omit<React$1.ComponentProps<typeof AccordionTrigger>, 'chevronPosition' | 'chevronVariant'> & {
+    label: string;
+    chevronVariant?: Extract<AccordionChevronVariant, 'tree' | 'tree-sm'>;
+};
+declare const FolderTreeExpandTrigger: React$1.FC<FolderTreeExpandTriggerProps>;
+
+interface AnimatedDotsProps {
+    className?: string;
+}
+declare const AnimatedDots: React.FC<AnimatedDotsProps>;
+
+interface AsideTab {
+    id: string;
+    label?: string;
+    icon?: LucideIcon | React.FC;
+    to?: string;
+    title?: string;
+    onClick?: () => void;
+}
+interface AsideProps {
+    tabs: AsideTab[];
+    activeId?: string;
+    className?: string;
+}
+declare const Aside: React.FC<AsideProps>;
+
+declare const badgeVariants: (props?: ({
+    variant?: "secondary" | "outline" | "yellow" | "purple" | "default" | "dark" | "defaultOutline" | "warning" | "critical" | "success" | "lightBlue" | "redViolet" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+    onRemove?: () => void;
+}
+declare function Badge({ className, variant, onRemove, children, ...props }: BadgeProps): React$1.JSX.Element;
+
+type ButtonBaseProps = VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+    loading?: boolean;
+};
+type ButtonAsButton = ButtonBaseProps & React__default.ComponentProps<'button'> & {
+    to?: never;
+    href?: never;
+};
+type ButtonAsLink = ButtonBaseProps & Omit<LinkProps, 'to'> & {
+    to: LinkProps['to'];
+    href?: never;
+    disabled?: never;
+};
+type ButtonAsAnchor = ButtonBaseProps & React__default.ComponentProps<'a'> & {
+    href: string;
+    to?: never;
+    disabled?: never;
+};
+type ButtonProps = ButtonAsButton | ButtonAsLink | ButtonAsAnchor;
+declare const buttonVariants: (props?: ({
+    variant?: "primary" | "primaryOutline" | "secondary" | "secondaryOutline" | "criticalOutline" | "ghost" | "outline" | "icon" | "custom" | null | undefined;
+    size?: "s" | "custom" | "xxs" | "xs" | "m" | "l" | "xl" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const Button: ({ className, variant, size, asChild, loading, children, disabled, to, href, ...props }: ButtonProps) => React__default.JSX.Element;
+
+declare const Checkbox: ({ className, ...props }: React.ComponentProps<typeof CheckboxPrimitive.Root>) => React$1.JSX.Element;
+
+type CheckboxProps = ComponentProps<typeof Checkbox>;
+
+interface ConditionalContentProps {
+    loading: boolean;
+    loadingContent: React.ReactNode;
+    loadedContent: React.ReactNode;
+}
+declare const ConditionalContent: React.FC<ConditionalContentProps>;
+
+interface DeleteButtonConfirmProps {
+    title: string;
+    message: React.ReactNode;
+    loading: boolean;
+    isOpen?: boolean;
+    onOpen?: () => void;
+    onClose?: () => void;
+    onConfirm: () => void;
+}
+declare const DeleteButtonConfirm: React.FC<DeleteButtonConfirmProps>;
+
+interface ConfirmDeleteDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: () => Promise<void> | void;
+    title: string;
+    message: React.ReactNode;
+    loading?: boolean;
+}
+declare const ConfirmDeleteDialog: React.FC<ConfirmDeleteDialogProps>;
+
+interface DefaultDialogProps {
+    isOpen: boolean;
+    disabled?: boolean;
+    title: React.ReactNode;
+    titleDescription?: React.ReactNode;
+    children: React.ReactNode;
+    loading?: boolean;
+    confirmText?: React.ReactNode;
+    confirmVariant?: ButtonProps['variant'];
+    cancelText?: React.ReactNode;
+    className?: string;
+    classNameHeader?: string;
+    classNameTitle?: string;
+    classNameCloseButton?: string;
+    hideFooter?: boolean;
+    scrollable?: boolean;
+    scrollAreaClassName?: string;
+    onClose?: () => void;
+    onConfirm?: () => void;
+}
+declare const DefaultDialog: React.FC<DefaultDialogProps>;
+
+interface DialogProps extends React$1.ComponentProps<typeof DialogPrimitive.Root> {
+}
+interface DialogTriggerProps extends React$1.ComponentProps<typeof DialogPrimitive.Trigger> {
+}
+interface DialogPortalProps extends React$1.ComponentProps<typeof DialogPrimitive.Portal> {
+}
+interface DialogCloseProps extends React$1.ComponentProps<typeof DialogPrimitive.Close> {
+}
+interface DialogOverlayProps extends React$1.ComponentProps<typeof DialogPrimitive.Overlay> {
+}
+interface DialogContentProps extends React$1.ComponentProps<typeof DialogPrimitive.Content> {
+    hideCloseButton?: boolean;
+}
+interface DialogHeaderProps extends React$1.ComponentProps<'div'> {
+}
+interface DialogFooterProps extends React$1.ComponentProps<'div'> {
+}
+interface DialogTitleProps extends React$1.ComponentProps<typeof DialogPrimitive.Title> {
+}
+interface DialogDescriptionProps extends React$1.ComponentProps<typeof DialogPrimitive.Description> {
+}
+declare const Dialog: React$1.FC<DialogProps>;
+declare const DialogTrigger: React$1.FC<DialogTriggerProps>;
+declare const DialogPortal: React$1.FC<DialogPortalProps>;
+declare const DialogClose: React$1.FC<DialogCloseProps>;
+declare const DialogOverlay: React$1.FC<DialogOverlayProps>;
+declare const DialogContent: React$1.FC<DialogContentProps>;
+declare const DialogHeader: React$1.FC<DialogHeaderProps>;
+declare const DialogFooter: React$1.FC<DialogFooterProps>;
+declare const DialogTitle: React$1.FC<DialogTitleProps>;
+declare const DialogDescription: React$1.FC<DialogDescriptionProps>;
+
+declare function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>): React$1.JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>): React$1.JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): React$1.JSX.Element;
+declare function DropdownMenuContent({ className, sideOffset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Content>): React$1.JSX.Element;
+declare function DropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>): React$1.JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: 'default' | 'destructive';
+}): React$1.JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>): React$1.JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): React$1.JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>): React$1.JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+    inset?: boolean;
+}): React$1.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>): React$1.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<'span'>): React$1.JSX.Element;
+declare function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>): React$1.JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+}): React$1.JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): React$1.JSX.Element;
+
+interface DropdownsCheckboxOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+interface DropdownsCheckboxProps {
+    options: DropdownsCheckboxOption[];
+    value: string[];
+    onChange: (value: string[]) => void;
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    loading?: boolean;
+    label?: string;
+    showSelectAll?: boolean;
+    selectAllLabel?: string;
+}
+declare const DropdownsCheckbox: React__default.FC<DropdownsCheckboxProps>;
+
+interface DropdownsSelectOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+    icon?: React__default.ReactNode;
+    className?: string;
+}
+interface DropdownsSelectProps {
+    options: DropdownsSelectOption[];
+    value: string | null;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    loading?: boolean;
+    label?: string;
+    triggerIcon?: React__default.ReactNode;
+    triggerClassName?: string;
+}
+declare const DropdownsSelect: React__default.FC<DropdownsSelectProps>;
+
+type DropdownMenuProps = ComponentProps<typeof DropdownMenu>;
+type DropdownMenuCheckboxItemProps = ComponentProps<typeof DropdownMenuCheckboxItem>;
+type DropdownMenuContentProps = ComponentProps<typeof DropdownMenuContent>;
+type DropdownMenuGroupProps = ComponentProps<typeof DropdownMenuGroup>;
+type DropdownMenuItemProps = ComponentProps<typeof DropdownMenuItem>;
+type DropdownMenuLabelProps = ComponentProps<typeof DropdownMenuLabel>;
+type DropdownMenuPortalProps = ComponentProps<typeof DropdownMenuPortal>;
+type DropdownMenuRadioGroupProps = ComponentProps<typeof DropdownMenuRadioGroup>;
+type DropdownMenuRadioItemProps = ComponentProps<typeof DropdownMenuRadioItem>;
+type DropdownMenuSeparatorProps = ComponentProps<typeof DropdownMenuSeparator>;
+type DropdownMenuShortcutProps = ComponentProps<typeof DropdownMenuShortcut>;
+type DropdownMenuSubProps = ComponentProps<typeof DropdownMenuSub>;
+type DropdownMenuSubContentProps = ComponentProps<typeof DropdownMenuSubContent>;
+type DropdownMenuSubTriggerProps = ComponentProps<typeof DropdownMenuSubTrigger>;
+type DropdownMenuTriggerProps = ComponentProps<typeof DropdownMenuTrigger>;
+
+interface EmptyStateProps {
+    Icon?: React.FC<LucideProps>;
+    IconNode?: React.ReactNode;
+    title?: string;
+    description?: string;
+    path?: string;
+    action?: React.ReactNode;
+    actions?: React.ReactNode;
+    className?: string;
+    classNameContent?: string;
+}
+declare const EmptyState: React.FC<EmptyStateProps>;
+
+interface LabelProps extends React.ComponentProps<typeof LabelPrimitive.Root> {
+    component?: 'label' | 'span';
+}
+declare const Label: React.FC<LabelProps>;
+
+declare function FieldSet({ className, ...props }: React.ComponentProps<'fieldset'>): React$1.JSX.Element;
+declare function FieldLegend({ className, variant, ...props }: React.ComponentProps<'legend'> & {
+    variant?: 'legend' | 'label';
+}): React$1.JSX.Element;
+declare function FieldGroup({ className, ...props }: React.ComponentProps<'div'>): React$1.JSX.Element;
+declare const fieldVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | "responsive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Field({ className, orientation, ...props }: React.ComponentProps<'div'> & VariantProps<typeof fieldVariants>): React$1.JSX.Element;
+declare function FieldContent({ className, ...props }: React.ComponentProps<'div'>): React$1.JSX.Element;
+declare function FieldLabel({ className, ...props }: React.ComponentProps<typeof Label>): React$1.JSX.Element;
+declare function FieldTitle({ className, ...props }: React.ComponentProps<'div'>): React$1.JSX.Element;
+declare function FieldDescription({ className, ...props }: React.ComponentProps<'p'>): React$1.JSX.Element;
+declare function FieldSeparator({ children, className, ...props }: React.ComponentProps<'div'> & {
+    children?: React.ReactNode;
+}): React$1.JSX.Element;
+declare function FieldError({ className, children, errors, ...props }: React.ComponentProps<'div'> & {
+    errors?: Array<{
+        message?: string;
+    } | undefined>;
+}): React$1.JSX.Element | null;
+
+type FieldProps = ComponentProps<typeof Field>;
+type FieldContentProps = ComponentProps<typeof FieldContent>;
+type FieldDescriptionProps = ComponentProps<typeof FieldDescription>;
+type FieldErrorProps = ComponentProps<typeof FieldError>;
+type FieldGroupProps = ComponentProps<typeof FieldGroup>;
+type FieldLabelProps = ComponentProps<typeof FieldLabel>;
+type FieldLegendProps = ComponentProps<typeof FieldLegend>;
+type FieldSeparatorProps = ComponentProps<typeof FieldSeparator>;
+type FieldSetProps = ComponentProps<typeof FieldSet>;
+type FieldTitleProps = ComponentProps<typeof FieldTitle>;
+
+interface HelperTextProps {
+    children: React.ReactNode;
+    className?: string;
+}
+declare const HelperText: ({ children, className }: HelperTextProps) => React$1.JSX.Element;
+
+interface InputProps extends React.ComponentProps<'input'> {
+    loading?: boolean;
+    iconLeft?: React.ReactNode;
+    iconRight?: React.ReactNode;
+    tooltip?: React.ReactNode;
+    parentClassName?: string;
+}
+declare const Input: React.FC<InputProps>;
+
+interface InputNumberProps extends Omit<React.ComponentProps<'input'>, 'type'> {
+    parentClassName?: string;
+    onValueChange?: (value: number) => void;
+}
+declare const InputNumber: React$1.ForwardRefExoticComponent<Omit<InputNumberProps, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+
+interface InputPasswordProps extends InputProps {
+}
+declare const InputPassword: React.FC<InputPasswordProps>;
+
+interface TooltipProviderProps extends React$1.ComponentProps<typeof TooltipPrimitive.Provider> {
+    delayDuration?: number;
+}
+interface TooltipParentProps extends React$1.ComponentProps<typeof TooltipPrimitive.Root> {
+}
+interface TooltipTriggerProps extends React$1.ComponentProps<typeof TooltipPrimitive.Trigger> {
+}
+interface TooltipContentProps extends React$1.ComponentProps<typeof TooltipPrimitive.Content> {
+    classNameArrow?: string;
+}
+declare const TooltipProvider: React$1.FC<TooltipProviderProps>;
+declare const TooltipParent: React$1.FC<TooltipParentProps>;
+declare const TooltipTrigger: React$1.FC<TooltipTriggerProps>;
+declare const TooltipContent: React$1.FC<TooltipContentProps>;
+
+interface TooltipProps extends React.ComponentProps<typeof TooltipParent> {
+    className?: string;
+    classNameArrow?: string;
+    children: React.ReactNode;
+    content: React.ReactNode;
+}
+declare const Tooltip: React.FC<TooltipProps>;
+
+interface LabelInfoProps extends React.ComponentProps<typeof LabelPrimitive.Root> {
+    component?: 'label' | 'span';
+    tooltipProps: Omit<React.ComponentProps<typeof Tooltip>, 'children'>;
+}
+declare const LabelInfo: React.FC<LabelInfoProps>;
+
+interface MultiSelectOption {
+    label: string;
+    value: string;
+    badgeVariant?: VariantProps<typeof badgeVariants>['variant'];
+    typeLabel?: string;
+    disabled?: boolean;
+}
+interface MultiSelectProps {
+    loading?: boolean;
+    options: MultiSelectOption[];
+    value: string[];
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    maxDisplay?: number;
+    maxSelection?: number;
+    searchable?: boolean;
+    size?: 'sm' | 'default';
+    dropdownClassName?: string;
+    align?: 'start' | 'center' | 'end';
+    variant?: VariantProps<typeof badgeVariants>['variant'];
+    badgeClassNames?: string;
+    id?: string;
+    name?: string;
+    onChange: (value: string[]) => void;
+}
+declare function MultiSelect({ loading, options, value, placeholder, className, disabled, maxDisplay, maxSelection, searchable, size, dropdownClassName, align, variant, badgeClassNames, id, name, onChange, }: MultiSelectProps): React$1.JSX.Element;
+
+interface PageHeaderProps {
+    loading?: boolean;
+    title?: string;
+    titleIcon?: React__default.ReactNode;
+    backLink?: string;
+    description?: React__default.ReactNode;
+    descriptionSize?: 'sm' | 'md';
+    className?: string;
+    titleClassName?: string;
+    children?: React__default.ReactNode;
+}
+declare const PageHeader: React__default.FC<PageHeaderProps>;
+
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<React.ComponentProps<typeof Button>, 'size'> & React.ComponentProps<'a'>;
+declare function Pagination({ className, ...props }: React.ComponentProps<'nav'>): React$1.JSX.Element;
+declare function PaginationContent({ className, ...props }: React.ComponentProps<'ul'>): React$1.JSX.Element;
+declare function PaginationItem({ ...props }: React.ComponentProps<'li'>): React$1.JSX.Element;
+declare function PaginationLink({ className, isActive, ...props }: PaginationLinkProps): React$1.JSX.Element;
+declare function PaginationPrevious({ className, ...props }: React.ComponentProps<typeof PaginationLink>): React$1.JSX.Element;
+declare function PaginationNext({ className, ...props }: React.ComponentProps<typeof PaginationLink>): React$1.JSX.Element;
+declare function PaginationEllipsis({ className, ...props }: React.ComponentProps<'span'>): React$1.JSX.Element;
+
+interface PaginationWrapProps {
+    page: number;
+    totalPages: number;
+    maxVisible?: number;
+    limit?: number;
+    optionsPerPage?: {
+        label: string;
+        value: string;
+    }[];
+    setLimit?: (limit: number) => void;
+    onPageChange: (page: number) => void;
+    onItemsPerPageChange?: (itemsPerPage: number) => void;
+}
+declare const PaginationWrap: React.FC<PaginationWrapProps>;
+
+type PaginationProps = ComponentProps<typeof Pagination>;
+type PaginationContentProps = ComponentProps<typeof PaginationContent>;
+type PaginationEllipsisProps = ComponentProps<typeof PaginationEllipsis>;
+type PaginationItemProps = ComponentProps<typeof PaginationItem>;
+type PaginationNextProps = ComponentProps<typeof PaginationNext>;
+type PaginationPreviousProps = ComponentProps<typeof PaginationPrevious>;
+
+declare function RadioGroup({ className, ...props }: React$1.ComponentProps<typeof Root>): React$1.JSX.Element;
+declare function RadioGroupItem({ className, ...props }: React$1.ComponentProps<typeof Item>): React$1.JSX.Element;
+
+type RadioGroupProps = ComponentProps<typeof RadioGroup>;
+type RadioGroupItemProps = ComponentProps<typeof RadioGroupItem>;
+
+type ScrollAreaOrientation = 'vertical' | 'horizontal' | 'both';
+interface ScrollAreaProps extends React$1.ComponentProps<typeof ScrollAreaPrimitive.Root> {
+    orientation?: ScrollAreaOrientation;
+}
+declare function ScrollArea({ className, children, orientation, ...props }: ScrollAreaProps): React$1.JSX.Element;
+declare function ScrollBar({ className, orientation, ...props }: React$1.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>): React$1.JSX.Element;
+
+interface SearchInputProps extends InputProps {
+    classNamesInput?: string;
+}
+declare const SearchInput: React.FC<SearchInputProps>;
+
+interface SearchInputFieldsProps extends InputProps {
+    classNamesInput?: string;
+    options: DropdownsSelectOption[];
+    valueSelect: string;
+    onChangeSelect: (value: string) => void;
+}
+declare const SearchInputFields: React.FC<SearchInputFieldsProps>;
+
+declare function Select({ ...props }: React$1.ComponentProps<typeof SelectPrimitive.Root>): React$1.JSX.Element;
+declare function SelectGroup({ ...props }: React$1.ComponentProps<typeof SelectPrimitive.Group>): React$1.JSX.Element;
+declare function SelectValue({ ...props }: React$1.ComponentProps<typeof SelectPrimitive.Value>): React$1.JSX.Element;
+declare function SelectTrigger({ className, size, children, loading, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Trigger> & {
+    size?: 'sm' | 'default';
+    loading?: boolean;
+}): React$1.JSX.Element;
+declare function SelectContent({ className, children, position, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Content>): React$1.JSX.Element;
+declare function SelectLabel({ className, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Label>): React$1.JSX.Element;
+declare function SelectItem({ className, children, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Item>): React$1.JSX.Element;
+declare function SelectSeparator({ className, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Separator>): React$1.JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React$1.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): React$1.JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React$1.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): React$1.JSX.Element;
+
+interface SelectDefaultProps {
+    id?: string;
+    name?: string;
+    options: {
+        label: string;
+        value: string;
+    }[];
+    placeholder: string;
+    className?: string;
+    value?: string;
+    loading?: boolean;
+    disabled?: boolean;
+    style?: React.CSSProperties;
+    renderItemLabel?: (value: string) => React.ReactNode;
+    renderTriggerLabel?: (value: string) => React.ReactNode;
+    onChange?: (value: string) => void;
+}
+declare const SelectDefault: React.FC<SelectDefaultProps>;
+
+type SelectProps = ComponentProps<typeof Select>;
+type SelectContentProps = ComponentProps<typeof SelectContent>;
+type SelectGroupProps = ComponentProps<typeof SelectGroup>;
+type SelectItemProps = ComponentProps<typeof SelectItem>;
+type SelectLabelProps = ComponentProps<typeof SelectLabel>;
+type SelectScrollDownButtonProps = ComponentProps<typeof SelectScrollDownButton>;
+type SelectScrollUpButtonProps = ComponentProps<typeof SelectScrollUpButton>;
+type SelectSeparatorProps = ComponentProps<typeof SelectSeparator>;
+type SelectTriggerProps = ComponentProps<typeof SelectTrigger>;
+type SelectValueProps = ComponentProps<typeof SelectValue>;
+
+declare function Separator({ className, orientation, decorative, ...props }: React$1.ComponentProps<typeof Separator$1>): React$1.JSX.Element;
+
+type SeparatorProps = ComponentProps<typeof Separator>;
+
+interface SkeletonTableProps {
+    rows?: number;
+    columns?: number;
+    className?: string;
+}
+interface SkeletonProps {
+    rows?: number;
+    className?: string;
+}
+declare const Skeleton: ({ className, rows, ...props }: SkeletonProps) => React$1.JSX.Element | React$1.JSX.Element[];
+declare const SkeletonTable: ({ className, rows, columns }: SkeletonTableProps) => React$1.JSX.Element;
+
+interface SliderProps extends React$1.ComponentProps<typeof SliderPrimitive.Root> {
+    label?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    value?: number[];
+    showValue?: boolean;
+    unit?: string;
+    onValueChange?: (value: number[]) => void;
+    formatValue?: (value: number) => string;
+}
+declare const Slider: React$1.FC<SliderProps>;
+
+interface SpinnerProps extends React.ComponentProps<'svg'> {
+    size?: number;
+}
+declare const Spinner: React.FC<SpinnerProps>;
+declare const SpinnerCustom: React.FC<SpinnerProps>;
+
+type SpinnerSquareProps = {
+    variant?: 'fixed' | 'absolute' | 'default';
+};
+declare const SpinnerSquare: FC<SpinnerSquareProps>;
+
+interface SuggestionOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+interface SuggestionsProps {
+    options: SuggestionOption[];
+    value?: string;
+    id?: string;
+    name?: string;
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    loading?: boolean;
+    dropdownClassName?: string;
+    minChars?: number;
+    showAllOnFocus?: boolean;
+    allowCustomValue?: boolean;
+    onChange: (value: string) => void;
+}
+declare const Suggestions: React.FC<SuggestionsProps>;
+
+declare const switchVariants: (props?: ({
+    size?: "s" | "m" | "l" | "xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SwitchProps extends React$1.ComponentProps<typeof SwitchPrimitive.Root>, VariantProps<typeof switchVariants> {
+    thumbClassName?: string;
+    tooltip?: React$1.ReactNode;
+}
+declare const Switch: React$1.FC<SwitchProps>;
+
+interface TableProps extends React.ComponentProps<'table'> {
+    classNameTable?: string;
+    orientation?: ScrollAreaOrientation;
+    classNameScrollArea?: string;
+}
+declare const Table: React.FC<TableProps>;
+declare const TableHeader: React.FC<React.ComponentProps<'thead'>>;
+declare const TableBody: React.FC<React.ComponentProps<'tbody'>>;
+declare const TableFooter: React.FC<React.ComponentProps<'tfoot'>>;
+declare const TableRow: React.FC<React.ComponentProps<'tr'>>;
+declare const TableHead: React.FC<React.ComponentProps<'th'>>;
+declare const TableCell: React.FC<React.ComponentProps<'td'>>;
+declare const TableCaption: React.FC<React.ComponentProps<'caption'>>;
+
+interface GroupHeaderRowProps {
+    colSpan: number;
+    label: string;
+    count: number;
+    isExpanded: boolean;
+    onToggle: () => void;
+}
+declare const GroupHeaderRow: ({ colSpan, label, count, isExpanded, onToggle, }: GroupHeaderRowProps) => React$1.JSX.Element;
+
+interface ServerGroupedTableBodyProps<TData extends RowData> {
+    groups: [string, TData[]][];
+    expandedGroups: Record<string, boolean>;
+    onToggleGroup: (groupKey: string) => void;
+    table: Table$1<TData>;
+    columnsCount: number;
+    classNameCell?: string;
+}
+declare const ServerGroupedTableBody: <TData extends RowData>({ groups, expandedGroups, onToggleGroup, table, columnsCount, classNameCell, }: ServerGroupedTableBodyProps<TData>) => React$1.JSX.Element;
+
+interface SortableHeaderProps {
+    header: Header<any, unknown>;
+    isSortingEnabled: boolean;
+}
+declare const SortableHeader: React__default.FC<SortableHeaderProps>;
+
+interface TableWrapProps<T> extends Omit<ScrollAreaProps, 'children'> {
+    classNameScrollArea?: string;
+    table: Table$1<T>;
+    columns: ColumnDef<T>[];
+    data?: T[];
+    orientation?: ScrollAreaOrientation;
+    loading?: boolean;
+    rowSelection?: Record<string, boolean>;
+    loadedContent?: React.ReactNode;
+    emptyContent?: React.ReactNode;
+    classNameHeader?: string;
+    classNameCell?: string;
+    classNameTable?: string;
+}
+declare function TableWrapInner<T>({ className, classNameTable, classNameScrollArea, classNameHeader, classNameCell, table, columns, data: _data, orientation, loading, rowSelection: _rowSelection, loadedContent, emptyContent, }: TableWrapProps<T>): React$1.JSX.Element;
+declare const TableWrap: typeof TableWrapInner;
+
+type TableBodyProps = ComponentProps<typeof TableBody>;
+type TableCaptionProps = ComponentProps<typeof TableCaption>;
+type TableCellProps = ComponentProps<typeof TableCell>;
+type TableFooterProps = ComponentProps<typeof TableFooter>;
+type TableHeadProps = ComponentProps<typeof TableHead>;
+type TableHeaderProps = ComponentProps<typeof TableHeader>;
+type TableRowProps = ComponentProps<typeof TableRow>;
+
+interface TabItem {
+    value: string;
+    label: React.ReactNode;
+    content?: React.ReactNode;
+    Content?: React.ComponentType;
+    disabled?: boolean;
+}
+interface TabsProps {
+    tabs: TabItem[];
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    className?: string;
+    tabsListClassName?: string;
+    tabsContentClassName?: string;
+    tabClassName?: string;
+}
+declare function Tabs({ tabs, defaultValue, value, className, tabClassName, tabsListClassName, tabsContentClassName, onValueChange, }: TabsProps): React$1.JSX.Element;
+
+interface TextTruncateProps {
+    children: React__default.ReactNode;
+    lines?: number;
+    className?: string;
+    textClassName?: string;
+    showToggle?: boolean;
+    showCopy?: boolean;
+}
+declare const TextTruncate: React__default.FC<TextTruncateProps>;
+
+declare function Textarea({ className, ...props }: React$1.ComponentProps<'textarea'>): React$1.JSX.Element;
+
+type TextareaProps = ComponentProps<typeof Textarea>;
+
+declare function ThemeToggle(): React$1.JSX.Element;
+
+type ThemeToggleProps = ComponentProps<typeof ThemeToggle>;
+
+declare const Toaster: React.FC<ToasterProps>;
+
+declare function TreeGuide({ className, children, ...props }: ComponentProps<'div'>): React$1.JSX.Element;
+declare function TreeRow({ className, children, ...props }: ComponentProps<'div'>): React$1.JSX.Element;
+
+type TreeGuideProps = ComponentProps<typeof TreeGuide>;
+type TreeRowProps = ComponentProps<typeof TreeRow>;
+
+export { Accordion, type AccordionChevronVariant, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionSection, type AccordionSectionProps, AccordionTrigger, type AccordionTriggerProps, AnimatedDots, type AnimatedDotsProps, Aside, type AsideProps, type AsideTab, Badge, type BadgeProps, Button, type ButtonProps, Checkbox, type CheckboxProps, ConditionalContent, type ConditionalContentProps, ConfirmDeleteDialog, type ConfirmDeleteDialogProps, ConfirmDeleteDialog as ConfirmDialog, DefaultDialog, type DefaultDialogProps, DeleteButtonConfirm, type DeleteButtonConfirmProps, Dialog, DialogClose, type DialogCloseProps, DialogContent, type DialogContentProps, DialogDescription, type DialogDescriptionProps, DialogFooter, type DialogFooterProps, DialogHeader, type DialogHeaderProps, DialogOverlay, type DialogOverlayProps, DialogPortal, type DialogPortalProps, type DialogProps, DialogTitle, type DialogTitleProps, DialogTrigger, type DialogTriggerProps, DropdownMenu, DropdownMenuCheckboxItem, type DropdownMenuCheckboxItemProps, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuGroup, type DropdownMenuGroupProps, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuLabelProps, DropdownMenuPortal, type DropdownMenuPortalProps, type DropdownMenuProps, DropdownMenuRadioGroup, type DropdownMenuRadioGroupProps, DropdownMenuRadioItem, type DropdownMenuRadioItemProps, DropdownMenuSeparator, type DropdownMenuSeparatorProps, DropdownMenuShortcut, type DropdownMenuShortcutProps, DropdownMenuSub, DropdownMenuSubContent, type DropdownMenuSubContentProps, type DropdownMenuSubProps, DropdownMenuSubTrigger, type DropdownMenuSubTriggerProps, DropdownMenuTrigger, type DropdownMenuTriggerProps, DropdownsCheckbox, type DropdownsCheckboxOption, type DropdownsCheckboxProps, DropdownsSelect, type DropdownsSelectOption, type DropdownsSelectProps, EmptyState, type EmptyStateProps, Field, FieldContent, type FieldContentProps, FieldDescription, type FieldDescriptionProps, FieldError, type FieldErrorProps, FieldGroup, type FieldGroupProps, FieldLabel, type FieldLabelProps, FieldLegend, type FieldLegendProps, type FieldProps, FieldSeparator, type FieldSeparatorProps, FieldSet, type FieldSetProps, FieldTitle, type FieldTitleProps, FolderTreeExpandTrigger, type FolderTreeExpandTriggerProps, GroupHeaderRow, type GroupHeaderRowProps, HelperText, type HelperTextProps, Input, InputNumber, type InputNumberProps, InputPassword, type InputPasswordProps, type InputProps, Label, LabelInfo, type LabelInfoProps, type LabelProps, MultiSelect, type MultiSelectOption, type MultiSelectProps, PageHeader, type PageHeaderProps, Pagination, PaginationContent, type PaginationContentProps, PaginationEllipsis, type PaginationEllipsisProps, PaginationItem, type PaginationItemProps, PaginationLink, type PaginationLinkProps, PaginationNext, type PaginationNextProps, PaginationPrevious, type PaginationPreviousProps, type PaginationProps, PaginationWrap, type PaginationWrapProps, RadioGroup, RadioGroupItem, type RadioGroupItemProps, type RadioGroupProps, ScrollArea, type ScrollAreaOrientation, type ScrollAreaProps, ScrollBar, SearchInput, SearchInputFields, type SearchInputFieldsProps, type SearchInputProps, Select, SelectContent, type SelectContentProps, SelectDefault, type SelectDefaultProps, SelectGroup, type SelectGroupProps, SelectItem, type SelectItemProps, SelectLabel, type SelectLabelProps, type SelectProps, SelectScrollDownButton, type SelectScrollDownButtonProps, SelectScrollUpButton, type SelectScrollUpButtonProps, SelectSeparator, type SelectSeparatorProps, SelectTrigger, type SelectTriggerProps, SelectValue, type SelectValueProps, Separator, type SeparatorProps, ServerGroupedTableBody, type ServerGroupedTableBodyProps, Skeleton, type SkeletonProps, SkeletonTable, type SkeletonTableProps, Slider, type SliderProps, SortableHeader, type SortableHeaderProps, Spinner, SpinnerCustom, type SpinnerProps, SpinnerSquare, type SpinnerSquareProps, type SuggestionOption, Suggestions, type SuggestionsProps, Switch, type SwitchProps, type TabItem, Table, TableBody, type TableBodyProps, TableCaption, type TableCaptionProps, TableCell, type TableCellProps, TableFooter, type TableFooterProps, TableHead, type TableHeadProps, TableHeader, type TableHeaderProps, type TableProps, TableRow, type TableRowProps, TableWrap, type TableWrapProps, Tabs, type TabsProps, TextTruncate, type TextTruncateProps, Textarea, type TextareaProps, ThemeToggle, type ThemeToggleProps, Toaster, Tooltip, TooltipContent, type TooltipContentProps, TooltipParent, type TooltipParentProps, type TooltipProps, TooltipProvider, type TooltipProviderProps, TooltipTrigger, type TooltipTriggerProps, TreeGuide, type TreeGuideProps, TreeRow, type TreeRowProps, badgeVariants, buttonVariants };