lecom-ui 4.2.2 → 4.3.0

package/dist/index.d.ts

@@ -1,29 +1,36 @@
 import * as class_variance_authority_types from 'class-variance-authority/types';
-import * as React from 'react';
+import * as React$1 from 'react';
 import * as AccordionPrimitive from '@radix-ui/react-accordion';
 import { VariantProps } from 'class-variance-authority';
 import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ColumnDef } from '@tanstack/react-table';
+import { Table, Column as Column$1, Row as Row$1 } from '@tanstack/react-table';
+export { ColumnDef } from '@tanstack/react-table';
 import * as DialogPrimitive from '@radix-ui/react-dialog';
 import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
 import { CustomStyles as CustomStyles$2 } from '@/components/Button';
 import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as SwitchPrimitives from '@radix-ui/react-switch';
 import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import { InitOptions } from 'i18next';
+export { TFunction, default as i18n } from 'i18next';
+export { Translation, useTranslation } from 'react-i18next';
 
 declare const accordionVariants: (props?: ({
     variant?: "default" | null | undefined;
     size?: "small" | "medium" | "large" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare const Accordion: React.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React.RefAttributes<HTMLDivElement>>;
-declare const AccordionItem: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const AccordionTrigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+declare const Accordion: React$1.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React$1.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
     variant?: "default" | null | undefined;
     size?: "small" | "medium" | "large" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
-declare const AccordionContent: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+} & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
     disabled?: boolean;
-} & React.RefAttributes<HTMLDivElement>>;
+} & React$1.RefAttributes<HTMLDivElement>>;
 
 declare const buttonVariants: (props?: ({
     variant?: "filled" | "outlined" | "tonal" | "ghost" | null | undefined;
@@ -48,26 +55,26 @@ interface CustomStyles$1 {
         opacity: number;
     };
 }
-interface ButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'color'>, VariantProps<typeof buttonVariants> {
+interface ButtonProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, 'color'>, VariantProps<typeof buttonVariants> {
     customStyles?: CustomStyles$1;
     isActive?: boolean;
 }
-declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
 
-declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const Card: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardContent: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
 
 declare const checkboxVariants: (props?: ({
     variant?: "default" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-interface CheckboxProps extends React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>, VariantProps<typeof checkboxVariants> {
+interface CheckboxProps extends React$1.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>, VariantProps<typeof checkboxVariants> {
     indeterminate?: boolean;
 }
-declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Checkbox: React$1.ForwardRefExoticComponent<CheckboxProps & React$1.RefAttributes<HTMLButtonElement>>;
 
 type Transparent = 'transparent';
 type Black = 'black';
@@ -210,89 +217,235 @@ declare const colors: {
     };
 };
 
-interface CadastroFacilProps extends React.SVGAttributes<SVGSVGElement> {
+interface CadastroFacilProps extends React$1.SVGAttributes<SVGSVGElement> {
     fillColor?: FillColor;
     size?: string | number;
 }
-declare const CadastroFacil: React.ForwardRefExoticComponent<CadastroFacilProps & React.RefAttributes<SVGSVGElement>>;
+declare const CadastroFacil: React$1.ForwardRefExoticComponent<CadastroFacilProps & React$1.RefAttributes<SVGSVGElement>>;
 
-interface LogoLecomProps extends React.SVGAttributes<SVGSVGElement> {
+interface LogoLecomProps extends React$1.SVGAttributes<SVGSVGElement> {
     fillColor?: FillColor;
     size?: string | number;
 }
-declare const LogoLecom: React.ForwardRefExoticComponent<LogoLecomProps & React.RefAttributes<SVGSVGElement>>;
+declare const LogoLecom: React$1.ForwardRefExoticComponent<LogoLecomProps & React$1.RefAttributes<SVGSVGElement>>;
 
-interface ModoTesteProps extends React.SVGAttributes<SVGSVGElement> {
+interface ModoTesteProps extends React$1.SVGAttributes<SVGSVGElement> {
     fillColor?: FillColor;
     size?: string | number;
 }
-declare const ModoTeste: React.ForwardRefExoticComponent<ModoTesteProps & React.RefAttributes<SVGSVGElement>>;
+declare const ModoTeste: React$1.ForwardRefExoticComponent<ModoTesteProps & React$1.RefAttributes<SVGSVGElement>>;
 
-interface RpaProps extends React.SVGAttributes<SVGSVGElement> {
+interface RpaProps extends React$1.SVGAttributes<SVGSVGElement> {
     fillColor?: FillColor;
     size?: string | number;
 }
-declare const Rpa: React.ForwardRefExoticComponent<RpaProps & React.RefAttributes<SVGSVGElement>>;
+declare const Rpa: React$1.ForwardRefExoticComponent<RpaProps & React$1.RefAttributes<SVGSVGElement>>;
 
-interface LogoLecomBrandProps extends React.SVGAttributes<SVGSVGElement> {
+interface LogoLecomBrandProps extends React$1.SVGAttributes<SVGSVGElement> {
     fillColor?: FillColor;
 }
-declare const LogoLecomBrand: React.ForwardRefExoticComponent<LogoLecomBrandProps & React.RefAttributes<SVGSVGElement>>;
+declare const LogoLecomBrand: React$1.ForwardRefExoticComponent<LogoLecomBrandProps & React$1.RefAttributes<SVGSVGElement>>;
 
+type UsePaginationProps = {
+    count?: number;
+    defaultPage?: number;
+    boundaryCount?: number;
+    siblingCount?: number;
+    disabled?: boolean;
+    hideNextButton?: boolean;
+    hidePrevButton?: boolean;
+    showFirstButton?: boolean;
+    showLastButton?: boolean;
+    onChange?: (value: number) => void;
+};
+type UsePaginationItem = {
+    id: string;
+    onClick: () => void;
+    type: string;
+    page: number | null;
+    selected: boolean;
+    disabled: boolean;
+    'aria-current'?: 'page';
+};
+declare const usePagination: ({ count, defaultPage, boundaryCount, siblingCount, disabled, hideNextButton, hidePrevButton, showFirstButton, showLastButton, onChange, }?: UsePaginationProps) => {
+    page: number;
+    setPage: React$1.Dispatch<React$1.SetStateAction<number>>;
+    items: UsePaginationItem[];
+};
+
+type PaginationButtonProps = {
+    className?: string;
+    disabled?: boolean;
+    isActive?: boolean;
+    asChild?: boolean;
+    onClick?: () => void;
+};
+interface PaginationIndexProps extends PaginationButtonProps {
+    children: React$1.ReactNode;
+}
+interface PaginationProps {
+    currentPage: number;
+    itemsPage: UsePaginationItem[];
+    totalPages: number;
+    perPage: number;
+    totalRowsSelected?: number;
+    onChangePerPage?: (currentPerPage: number) => void;
+}
+declare const PaginationContent: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
+declare const PaginationItem: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
+declare const PaginationFirst: {
+    ({ className, disabled, isActive, onClick, }: PaginationButtonProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const PaginationLast: {
+    ({ className, disabled, isActive, onClick, }: PaginationButtonProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const PaginationPrevious: {
+    ({ className, disabled, isActive, onClick, }: PaginationButtonProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const PaginationNext: {
+    ({ className, disabled, isActive, onClick, }: PaginationButtonProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const PaginationEllipsis: {
+    ({ className, disabled, isActive, asChild, onClick, }: PaginationButtonProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const PaginationIndex: {
+    ({ className, disabled, isActive, onClick, children, }: PaginationIndexProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const Pagination: {
+    ({ currentPage, itemsPage, perPage, totalRowsSelected, onChangePerPage, }: PaginationProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface ColumnRender<TData, TValue> {
+    row: Row$1<TData>;
+    value: TValue;
+}
+interface ColumnSort<TData, TValue> {
+    table: Table<TData>;
+    column: Column$1<TData, TValue>;
+}
+type ColumnTitle<TData, TValue> = ColumnSort<TData, TValue>;
+interface CheckedHeader<TData, TValue> {
+    table: Table<TData>;
+    column: Column$1<TData, TValue>;
+}
+interface CheckedHeaderChange<TData, TValue> {
+    table: Table<TData>;
+    column: Column$1<TData, TValue>;
+    value: boolean;
+}
+interface CheckedCell<TData> {
+    row: Row$1<TData>;
+}
+interface CheckedCellChange<TData> {
+    row: Row$1<TData>;
+    value: boolean;
+}
+interface Column<TData, TValue> {
+    key: string;
+    title?: (({ table, column }: ColumnTitle<TData, TValue>) => React.ReactNode) | React.ReactNode;
+    enableSelect?: boolean;
+    width?: number | string;
+    fixed?: string;
+    truncate?: boolean;
+    render?: (({ value, row }: ColumnRender<TData, TValue>) => React.ReactNode) | React.ReactNode;
+    onSort?: ({ table, column }: ColumnSort<TData, TValue>) => void;
+    checkedHeader?: ({ table, column }: CheckedHeader<TData, TValue>) => boolean;
+    checkedCell?: ({ row }: CheckedCell<TData>) => boolean;
+    onCheckedHeaderChange?: ({ table, column, value, }: CheckedHeaderChange<TData, TValue>) => void;
+    onCheckedCellChange?: ({ row, value }: CheckedCellChange<TData>) => void;
+}
 interface DataTableProps<TData, TValue> {
-    columns: ColumnDef<TData, TValue>[];
+    isLoading?: boolean;
+    columns: Column<TData, TValue>[];
     data: TData[];
     noResults?: React.ReactNode;
+    pagination?: PaginationProps;
+    vwDiff?: number;
+    vhDiff?: number;
+    onIsSelected?: (row: Row$1<TData>) => boolean;
+}
+interface Row<TData> {
+    row: Row$1<TData>;
+}
+interface Header<TData, TValue> {
+    table: Table<TData>;
+    column: Column$1<TData, TValue>;
 }
-declare function DataTable<TData, TValue>({ columns, data, noResults, }: DataTableProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+interface BuildColumns<TData, TValue> {
+    columns: Column<TData, TValue>[];
+}
+interface BuildHeaderSelect<TData, TValue> {
+    table: Table<TData>;
+    column: Column$1<TData, TValue>;
+    checkedHeader: Column<TData, TValue>['checkedHeader'];
+    onCheckedHeaderChange: Column<TData, TValue>['onCheckedHeaderChange'];
+}
+interface BuildCellSelect<TData, TValue> {
+    row: Row$1<TData>;
+    checkedCell: Column<TData, TValue>['checkedCell'];
+    onCheckedCellChange: Column<TData, TValue>['onCheckedCellChange'];
+}
+type Meta = Record<string, string | number>;
 
-declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
-declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
-declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
-declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare function DataTable<TData, TValue>({ isLoading, columns, data, noResults, pagination, vwDiff, vhDiff, onIsSelected, }: DataTableProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+declare namespace DataTable {
+    var displayName: string;
+}
+
+declare const Dialog: React$1.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 declare const DialogHeader: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
 declare const DialogFooter: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
-declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
-declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
-
-declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
-declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
-declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
-declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+declare const DialogTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const DropdownMenu: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React$1.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
     inset?: boolean;
-} & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
     inset?: boolean;
-} & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
     inset?: boolean;
-} & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 declare const DropdownMenuShortcut: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
 
 interface HelpMenuItem {
-    icon?: React.ReactNode;
+    icon?: React$1.ReactNode;
     description?: string;
     disabled?: boolean;
-    render?: React.ReactNode;
+    render?: React$1.ReactNode;
     onClick?: () => void;
 }
 interface HelpMenuProps {
@@ -304,14 +457,14 @@ interface HelpMenuProps {
 
 interface ModulesMenuItem {
     containerIconBgColor?: BgColor;
-    icon?: React.ReactNode;
+    icon?: React$1.ReactNode;
     title?: string;
     description?: string;
     disabled?: boolean;
-    render?: React.ReactNode;
+    render?: React$1.ReactNode;
     bgColor: string;
     textColor: string;
-    highlight?: React.ReactNode;
+    highlight?: React$1.ReactNode;
     onClick?: () => void;
 }
 interface ModulesMenuProps {
@@ -336,22 +489,22 @@ interface UserMenuProps {
     user?: {
         name: string;
         email: string;
-        render?: React.ReactNode;
+        render?: React$1.ReactNode;
     };
     language?: {
-        icon?: React.ReactNode;
+        icon?: React$1.ReactNode;
         label?: string;
         select?: {
             options: LanguageOption[];
             value?: string;
             onChange?: (language: string) => void;
         };
-        render?: React.ReactNode;
+        render?: React$1.ReactNode;
     };
     logout?: {
-        icon: React.ReactNode;
+        icon: React$1.ReactNode;
         label: string;
-        render?: React.ReactNode;
+        render?: React$1.ReactNode;
         onClick: () => void;
     };
 }
@@ -361,7 +514,7 @@ interface CustomStyles {
     bgColor: string;
     textColor: string;
 }
-interface HeaderProps extends React.HTMLAttributes<HTMLElement>, VariantProps<typeof headerVariants> {
+interface HeaderProps extends React$1.HTMLAttributes<HTMLElement>, VariantProps<typeof headerVariants> {
     customStyles: CustomStyles;
     module?: string;
     customImgSrc?: string;
@@ -369,7 +522,7 @@ interface HeaderProps extends React.HTMLAttributes<HTMLElement>, VariantProps<ty
     userMenu?: Omit<UserMenuProps, 'customStyles'>;
     helpMenu?: Omit<HelpMenuProps, 'customStyles'>;
     modulesMenu?: Omit<ModulesMenuProps, 'customStyles'>;
-    extraContent?: React.ReactNode;
+    extraContent?: React$1.ReactNode;
     onOpenMenuChange?: () => void;
 }
 
@@ -378,17 +531,20 @@ interface SideBarProps {
         title: string;
         onClick?: () => void;
         url?: string;
-        icon: React.ReactNode;
+        icon: React$1.ReactNode;
         isActive?: boolean;
     }[];
     info: {
+        platformText: string;
+        authorizedForText: string;
         authorizedFor: string;
         build: string;
         cycle: string;
+        versionText: string;
         version: string;
     };
 }
-interface LayoutProps extends React.HTMLAttributes<HTMLDivElement> {
+interface LayoutProps extends React$1.HTMLAttributes<HTMLDivElement> {
     header: HeaderProps;
     sideBar: SideBarProps;
 }
@@ -407,7 +563,7 @@ declare const notificationVariants: (props?: ({
     variant?: "success" | "error" | "information" | "warning" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 type BaseNotificationProps = VariantProps<typeof notificationVariants> & {
-    action?: React.ReactNode;
+    action?: React$1.ReactNode;
 };
 interface ToastNotificationProps extends BaseNotificationProps {
     type: 'toast';
@@ -418,18 +574,18 @@ interface ToastNotificationProps extends BaseNotificationProps {
 }
 interface CalloutNotificationProps extends BaseNotificationProps {
     type: 'callout';
-    title?: React.ReactNode;
-    content: React.ReactNode;
+    title?: React$1.ReactNode;
+    content: React$1.ReactNode;
     shouldExpand?: boolean;
-    action?: React.ReactNode;
+    action?: React$1.ReactNode;
 }
 interface InlineNotificationProps extends BaseNotificationProps {
     type: 'inline';
-    title?: React.ReactNode;
-    content: React.ReactNode;
+    title?: React$1.ReactNode;
+    content: React$1.ReactNode;
     enableClose?: boolean;
     shouldExpand?: boolean;
-    action?: React.ReactNode;
+    action?: React$1.ReactNode;
 }
 type NotificationProps = ToastNotificationProps | CalloutNotificationProps | InlineNotificationProps;
 declare const posistionMap: {
@@ -439,15 +595,15 @@ declare const posistionMap: {
     readonly bottomLeft: "bottom-0 left-0";
 };
 declare const getPositionClass: (type: string, placement?: keyof typeof posistionMap) => "" | "top-0 right-0" | "top-0 left-0" | "bottom-0 right-0" | "bottom-0 left-0";
-declare const Notification: React.ForwardRefExoticComponent<NotificationProps & React.RefAttributes<HTMLDivElement>>;
+declare const Notification: React$1.ForwardRefExoticComponent<NotificationProps & React$1.RefAttributes<HTMLDivElement>>;
 
 declare const TOAST_REMOVE_DELAY = 5000;
 type ToasterToast = {
     id: string;
-    title?: React.ReactNode;
-    content: React.ReactNode;
+    title?: React$1.ReactNode;
+    content: React$1.ReactNode;
     variant: 'success' | 'error' | 'warning' | 'information';
-    action?: React.ReactNode;
+    action?: React$1.ReactNode;
     toastLimit?: number;
     duration?: number;
     open: boolean;
@@ -496,38 +652,41 @@ declare function useNotificationToast(): {
     pauseNotification: (toastId?: string) => void;
 };
 
-declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
-declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Popover: React$1.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Skeleton: ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>) => react_jsx_runtime.JSX.Element;
 
-declare const Skeleton: ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => react_jsx_runtime.JSX.Element;
+declare const Switch: React$1.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
 
 declare const tagVariants: (props?: ({
     color?: "blue" | "grey" | "purple" | "yellow" | "red" | "orange" | "green" | "pink" | "turquoise" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-interface TagProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'color'>, VariantProps<typeof tagVariants> {
-    children: React.ReactNode;
+interface TagProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, 'color'>, VariantProps<typeof tagVariants> {
+    children: React$1.ReactNode;
 }
-declare const Tag: React.ForwardRefExoticComponent<TagProps & React.RefAttributes<HTMLDivElement>>;
+declare const Tag: React$1.ForwardRefExoticComponent<TagProps & React$1.RefAttributes<HTMLDivElement>>;
 
-declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
-declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
-declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const TooltipArrow: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipArrowProps & React.RefAttributes<SVGSVGElement>>;
+declare const TooltipProvider: React$1.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React$1.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TooltipArrow: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipArrowProps & React$1.RefAttributes<SVGSVGElement>>;
+declare const TooltipPortal: React$1.FC<TooltipPrimitive.TooltipPortalProps>;
 declare const tooltipContentVariants: (props?: ({
-    color?: "white" | "black" | null | undefined;
+    color?: "black" | "white" | null | undefined;
     arrow?: boolean | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-interface TooltipContentProps extends React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>, VariantProps<typeof tooltipContentVariants> {
+interface TooltipContentProps extends React$1.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>, VariantProps<typeof tooltipContentVariants> {
     color?: 'white' | 'black';
     arrow?: boolean;
 }
-declare const TooltipContent: React.ForwardRefExoticComponent<TooltipContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const TooltipContent: React$1.ForwardRefExoticComponent<TooltipContentProps & React$1.RefAttributes<HTMLDivElement>>;
 
 declare const typographyVariants: (props?: ({
-    variant?: "heading-xxlarge-500" | "heading-xlarge-500" | "heading-large-600" | "heading-large-500" | "heading-medium-600" | "heading-medium-500" | "heading-small-600" | "heading-small-500" | "heading-xsmall-600" | "heading-xsmall-500" | "heading-xxsmall-500" | "body-large-700" | "body-large-500" | "body-large-400" | "body-medium-700" | "body-medium-500" | "body-medium-400" | "body-small-700" | "body-small-500" | "body-small-400" | "code-medium-400" | null | undefined;
+    variant?: "heading-xxlarge-500" | "heading-xlarge-500" | "heading-large-600" | "heading-large-500" | "heading-medium-600" | "heading-medium-500" | "heading-small-600" | "heading-small-500" | "heading-xsmall-600" | "heading-xsmall-500" | "heading-xxsmall-600" | "heading-xxsmall-500" | "body-large-700" | "body-large-500" | "body-large-400" | "body-medium-700" | "body-medium-500" | "body-medium-400" | "body-small-700" | "body-small-500" | "body-small-400" | "code-medium-400" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-interface TypographyProps extends Omit<React.HTMLAttributes<HTMLElement>, 'tag'>, VariantProps<typeof typographyVariants> {
+interface TypographyProps extends Omit<React$1.HTMLAttributes<HTMLElement>, 'tag'>, VariantProps<typeof typographyVariants> {
     textColor?: TextColor;
     tag?: any;
 }
@@ -536,6 +695,45 @@ declare const Typography: {
     displayName: string;
 };
 
+declare const RadioGroup: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const RadioGroupItem: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const ScrollArea: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+interface SpinProps extends React$1.SVGAttributes<SVGSVGElement> {
+    textColor?: TextColor;
+    size?: string | number;
+}
+declare const Spin: React$1.ForwardRefExoticComponent<SpinProps & React$1.RefAttributes<SVGSVGElement>>;
+
+type SidebarContext = {
+    state: 'expanded' | 'collapsed';
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
+};
+declare const SidebarContext: React$1.Context<SidebarContext | null>;
+declare function useSidebar(): SidebarContext;
+
+declare function useIsMobile(): boolean;
+
+declare enum Translations {
+    PT_BR = "pt_BR",
+    EN_US = "en_US",
+    ES_ES = "es_ES"
+}
+interface InitializeI18n {
+    resources?: {
+        [key in Translations]: InitOptions['resources'];
+    };
+    lng?: Translations;
+}
+declare const initializeI18n: (options?: InitializeI18n) => void;
+
 type Fonts = 'roboto' | 'montserrat' | 'ibm';
 declare const fonts: {
     roboto: string[];
@@ -543,5 +741,5 @@ declare const fonts: {
     ibm: string[];
 };
 
-export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Button, CadastroFacil, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, DataTable, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, Layout, LogoLecom, LogoLecomBrand, ModoTeste, Notification, Popover, PopoverContent, PopoverTrigger, Rpa, Skeleton, TOAST_REMOVE_DELAY, Tag, Tooltip, TooltipArrow, TooltipContent, TooltipProvider, TooltipTrigger, TypeMessageNotification, Typography, accordionVariants, buttonVariants, colors, fonts, getPositionClass, notificationVariants, reducer, tagVariants, toast, typographyVariants, useNotificationToast };
-export type { BgColor, ButtonProps, CadastroFacilProps, CalloutNotificationProps, CheckboxProps, Color, ColorToken, CustomStyles$1 as CustomStyles, FillColor, Fonts, HeaderProps, InlineNotificationProps, LayoutProps, LogoLecomBrandProps, LogoLecomProps, ModoTesteProps, NotificationProps, RpaProps, SideBarProps, TagProps, TextColor, ToastNotificationProps, ToasterToast, TooltipContentProps, TypographyProps };
+export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Button, CadastroFacil, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, DataTable, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, Layout, LogoLecom, LogoLecomBrand, ModoTeste, Notification, Pagination, PaginationContent, PaginationEllipsis, PaginationFirst, PaginationIndex, PaginationItem, PaginationLast, PaginationNext, PaginationPrevious, Popover, PopoverContent, PopoverTrigger, RadioGroup, RadioGroupItem, Rpa, ScrollArea, ScrollBar, Skeleton, Spin, Switch, TOAST_REMOVE_DELAY, Tag, Tooltip, TooltipArrow, TooltipContent, TooltipPortal, TooltipProvider, TooltipTrigger, Translations, TypeMessageNotification, Typography, accordionVariants, buttonVariants, colors, fonts, getPositionClass, initializeI18n, notificationVariants, reducer, tagVariants, toast, typographyVariants, useIsMobile, useNotificationToast, usePagination, useSidebar };
+export type { BgColor, BuildCellSelect, BuildColumns, BuildHeaderSelect, ButtonProps, CadastroFacilProps, CalloutNotificationProps, CheckboxProps, CheckedCell, CheckedCellChange, CheckedHeader, CheckedHeaderChange, Color, ColorToken, Column, ColumnRender, ColumnSort, ColumnTitle, CustomStyles$1 as CustomStyles, DataTableProps, FillColor, Fonts, Header, HeaderProps, InlineNotificationProps, LayoutProps, LogoLecomBrandProps, LogoLecomProps, Meta, ModoTesteProps, NotificationProps, PaginationProps, Row, RpaProps, SideBarProps, SpinProps, TagProps, TextColor, ToastNotificationProps, ToasterToast, TooltipContentProps, TypographyProps, UsePaginationItem };