@giro-ds/react 1.0.0

package/dist/components/Filter/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './Filter';
+export type { FilterProps } from './Filter.types';

package/dist/components/ListItem/ListItem.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { ListItemProps } from './ListItem.types';
+/**
+ * Componente ListItem do Zanthus Design System
+ * Implementa item de lista unificado com variações text, checkbox, radio e icon
+ * Segue padrões WCAG 2.1 AA para acessibilidade
+ */
+declare const ListItem: React.FC<ListItemProps>;
+export default ListItem;

package/dist/components/ListItem/ListItem.types.d.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+export type ListItemVariant = 'text' | 'checkbox' | 'radio' | 'icon';
+export interface ListItemProps {
+    /** ID único do componente */
+    id?: string;
+    /** Classes CSS customizadas */
+    className?: string;
+    /** Variante do item da lista */
+    variant?: ListItemVariant;
+    /** Texto principal do item */
+    text?: string;
+    /** Nome do input (para checkbox/radio) */
+    name?: string;
+    /** Texto secundário/descrição */
+    subText?: string;
+    /** Se o item está desabilitado */
+    disabled?: boolean;
+    /** Estado de checked (para checkbox/radio) */
+    checked?: boolean;
+    /** Estado de selecionado (para text/icon) */
+    selected?: boolean;
+    /** Callback para clique no item */
+    onClick?: (event: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
+    /** Callback para mudança de estado */
+    onChange?: (checked: boolean) => void;
+    /** Ícone do item (para variant icon) */
+    icon?: React.ReactNode;
+    /** Valor do input (para checkbox/radio) */
+    value?: string;
+    /** Se deve mostrar o subtexto */
+    showSubText?: boolean;
+    /** Estado de hover */
+    hovered?: boolean;
+}

package/dist/components/ListItem/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './ListItem';
+export type { ListItemProps } from './ListItem.types';

package/dist/components/Menu/Menu.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { MenuProps } from './Menu.types';
+declare const Menu: React.FC<MenuProps>;
+export default Menu;

package/dist/components/Menu/Menu.types.d.ts

@@ -0,0 +1,41 @@
+import { ReactNode, ReactElement } from 'react';
+export interface MenuItem {
+    /** ID único do item */
+    id: string;
+    /** Texto principal do item */
+    text: string;
+    /** Texto secundário opcional */
+    subText?: string;
+    /** Ícone do item */
+    icon?: ReactNode;
+    /** Estado desabilitado */
+    disabled?: boolean;
+    /** Valor customizado do item */
+    value?: unknown;
+}
+export interface MenuProps {
+    /** Elemento React que será usado como âncora do menu (obrigatório) */
+    children: ReactElement<any, any>;
+    /** Array de itens do menu */
+    menuItems?: MenuItem[];
+    /** Callback executado quando um item do menu é clicado */
+    onMenuItemClick?: (item: MenuItem) => void;
+    /** Callback executado quando o menu é aberto/fechado */
+    onToggle?: (isOpen: boolean) => void;
+    /** Tipo do dropdown */
+    type?: 'text' | 'icon';
+    /** Habilita campo de busca */
+    applySearch?: boolean;
+    /** Placeholder do campo de busca */
+    placeholder?: string;
+    /** Controla exibição do subtexto */
+    showSubText?: boolean;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** ID único do componente */
+    id?: string;
+    maxWidth?: string | number;
+    minWidth?: string | number;
+    /** Posição do menu em relação ao elemento âncora */
+    position?: 'left' | 'right';
+}

package/dist/components/Menu/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './Menu';
+export type { MenuProps, MenuItem } from './Menu.types';

package/dist/components/MenuRadix/MenuRadix.d.ts

@@ -0,0 +1,4 @@
+import { MenuRadixProps } from './MenuRadix.types';
+import React from 'react';
+declare const MenuRadix: React.FC<MenuRadixProps>;
+export default MenuRadix;

package/dist/components/MenuRadix/MenuRadix.types.d.ts

@@ -0,0 +1,27 @@
+import { ReactElement } from 'react';
+export interface MenuItemProps {
+    id?: string;
+    text?: string;
+    subText?: string;
+    disabled?: boolean;
+    icon?: React.ReactNode;
+    children?: MenuItemProps[];
+    value?: string;
+}
+export interface MenuRadixProps {
+    items: MenuItemProps[];
+    children?: ReactElement;
+    type?: 'text' | 'icon';
+    className?: string;
+    onItemSelect?: (items: MenuItemProps) => void;
+    selectedItems?: MenuItemProps[];
+    search?: boolean;
+    align?: 'start' | 'end' | 'center';
+    maxHeight?: number | string;
+    enableInfiniteScroll?: boolean;
+    onScrollEnd?: () => void;
+    isLoadingMore?: boolean;
+    enableApiSearch?: boolean;
+    onApiSearch?: (searchTerm: string) => void;
+    onOpenChange?: (open: boolean) => void;
+}

package/dist/components/MenuRadix/components/MenuItem.d.ts

@@ -0,0 +1,8 @@
+import { MenuItemProps } from '../MenuRadix.types';
+interface DefaultMenuItemProps {
+    item: MenuItemProps;
+    isSelected: boolean;
+    onSelect: (item: MenuItemProps) => void;
+}
+export declare const MenuItem: import("react").MemoExoticComponent<({ item, isSelected, onSelect }: DefaultMenuItemProps) => import("react/jsx-runtime").JSX.Element>;
+export default MenuItem;

package/dist/components/MenuRadix/hooks/useMenuLogic.d.ts

@@ -0,0 +1,15 @@
+import { MenuItemProps } from '../MenuRadix.types';
+export interface UseMenuLogicProps {
+    selectedItems?: MenuItemProps[];
+    onItemSelect?: (items: MenuItemProps) => void;
+    onOpenChange?: (open: boolean) => void;
+}
+export interface UseMenuLogicReturn {
+    open: boolean;
+    internalSelectedItems: MenuItemProps[];
+    setOpen: (open: boolean) => void;
+    handleItemSelect: (item: MenuItemProps) => void;
+    isItemSelected: (item: MenuItemProps) => boolean;
+}
+export declare function useMenuLogic({ selectedItems, onItemSelect, onOpenChange, }: UseMenuLogicProps): UseMenuLogicReturn;
+export default useMenuLogic;

package/dist/components/MenuRadix/hooks/useSearchLogic.d.ts

@@ -0,0 +1,13 @@
+import { MenuItemProps } from '../MenuRadix.types';
+interface UseSearchLogicProps {
+    items: MenuItemProps[];
+    searchValue: string;
+    searchTerm: string;
+    enableApiSearch?: boolean;
+    onApiSearch?: (term: string) => void;
+}
+interface UseSearchLogicReturn {
+    filteredItems: MenuItemProps[];
+}
+export declare const useSearchLogic: ({ items, searchValue, searchTerm, enableApiSearch, onApiSearch, }: UseSearchLogicProps) => UseSearchLogicReturn;
+export {};

package/dist/components/MenuRadix/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './MenuRadix';
+export type { MenuRadixProps, MenuItemProps } from './MenuRadix.types';

package/dist/components/Quantity/Quantity.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { QuantityProps } from './Quantity.types';
+declare const memorizedQuantity: React.NamedExoticComponent<QuantityProps>;
+export default memorizedQuantity;

package/dist/components/Quantity/Quantity.types.d.ts

@@ -0,0 +1,20 @@
+export interface QuantityProps {
+    /** Valor padrão inicial */
+    defaultValue?: number;
+    /** Valor controlado externamente */
+    value?: number;
+    /** Callback chamado quando o valor muda */
+    onChange?: (value: number) => void;
+    /** Define se o componente está desabilitado */
+    disabled?: boolean;
+    /** Define se o valor do input será decimal ou inteiro */
+    decimal?: boolean;
+    /** Define o tamanho do componente */
+    size?: 'lg' | 'sm';
+    /** Define o número de casas decimais quando decimal for true */
+    decimalPlaces?: number;
+    step?: number;
+    id?: string;
+    /** ClassName adicional para customização */
+    className?: string;
+}

package/dist/components/Quantity/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './Quantity';
+export type { QuantityProps } from './Quantity.types';

package/dist/components/Radio/Radio.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { RadioProps } from './Radio.types';
+declare const MemoizedRadio: React.NamedExoticComponent<RadioProps>;
+export default MemoizedRadio;

package/dist/components/Radio/Radio.types.d.ts

@@ -0,0 +1,18 @@
+export interface RadioProps {
+    /** Definirá o nome do grupo de radio */
+    name?: string;
+    /** O valor associado ao botão de rádio */
+    value: string;
+    /** O identificador único para o input do rádio */
+    id?: string;
+    /** Indica se o botão de rádio está selecionado */
+    checked?: boolean;
+    /** Classes adicionais para estilização personalizada */
+    className?: string;
+    /** Função de callback acionada quando o valor do botão de rádio muda */
+    onChange?: (value: string) => void;
+    /** O texto do rótulo exibido ao lado do botão de rádio */
+    label?: string;
+    /** Indica se o botão de rádio está desabilitado */
+    disabled?: boolean;
+}

package/dist/components/Radio/index.d.ts

@@ -0,0 +1 @@
+export { default } from './Radio';

package/dist/components/RadioRadix/RadioRadix.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { RadioGroupProps } from './RadioRadix.types';
+declare const RadioRadix: React.FC<RadioGroupProps>;
+export default RadioRadix;

package/dist/components/RadioRadix/RadioRadix.types.d.ts

@@ -0,0 +1,15 @@
+export interface RadioProps {
+    id?: string | number;
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+export interface RadioGroupProps {
+    id?: string;
+    items: RadioProps[];
+    onValueChange?: (value: string) => void;
+    defaultValue?: string;
+    name?: string;
+    ariaLabel?: string;
+    orientation?: "horizontal" | "vertical";
+}

package/dist/components/RadioRadix/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './RadioRadix';
+export type { RadioProps, RadioGroupProps } from './RadioRadix.types';

package/dist/components/Search/Search.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { SearchProps } from './Search.types';
+declare const Search: React.ForwardRefExoticComponent<SearchProps & React.RefAttributes<HTMLInputElement>>;
+export default Search;

package/dist/components/Search/Search.types.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+export interface SearchProps {
+    placeholder?: string;
+    disabled?: boolean;
+    value?: string;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+    onFocus?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    onBlur?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    onClear?: () => void;
+    onClick?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseDown?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    className?: string;
+    id?: string;
+}

package/dist/components/Search/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './Search';
+export type { SearchProps } from './Search.types';

package/dist/components/Select/Select.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { SelectProps } from './Select.types';
+declare const Select: React.NamedExoticComponent<SelectProps>;
+export default Select;

package/dist/components/Select/Select.types.d.ts

@@ -0,0 +1,67 @@
+import React from 'react';
+import { DropdownType } from '../Dropdown/Dropdown.types';
+export interface SelectOption {
+    /** ID único da opção (opcional, será gerado automaticamente se não fornecido) */
+    id?: string;
+    /** Texto principal da opção */
+    text: string;
+    /** Texto secundário/descrição da opção */
+    subText?: string;
+    /** Ícone da opção (React node) */
+    icon?: React.ReactNode;
+    /** Define se a opção está desabilitada */
+    disabled?: boolean;
+}
+export interface SelectProps {
+    /** ID único do componente */
+    id?: string;
+    /** Array de opções para seleção - obrigatório */
+    options: SelectOption[];
+    /** Valor(es) selecionado(s) */
+    value?: string | string[];
+    /** Valor inicial para seleção (usado apenas na primeira renderização) */
+    initialValue?: string | string[];
+    /** Callback para mudanças na seleção */
+    onChange?: (selectedItems: SelectOption[]) => void;
+    /** Placeholder do campo */
+    placeholder?: string;
+    /** Tipo do dropdown (single ou multiple) */
+    type?: DropdownType;
+    maxHeight?: string;
+    /** Label do campo */
+    label?: string;
+    /** Texto de ajuda */
+    helperText?: string;
+    /** Mensagem de erro */
+    errorMessage?: string;
+    /** Campo obrigatório */
+    required?: boolean;
+    /** Campo desabilitado */
+    disabled?: boolean;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** Texto para acessibilidade */
+    showSubText?: boolean;
+    /** Aria-label do campo */
+    ariaLabel?: string;
+    /** Habilita campo de busca */
+    applySearch?: boolean;
+    /** Placeholder do campo de busca */
+    searchPlaceholder?: string;
+    maxWidth?: string;
+    minWidth?: string;
+    tooltip?: boolean;
+    tooltipText?: string;
+    width?: string;
+    /** Força posição do dropdown: 'top' abre para cima, 'bottom' abre para baixo. Se não especificado, usa detecção automática */
+    position?: 'top' | 'bottom';
+    positionTooltip?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'left' | 'right';
+    infiniteScroll?: {
+        status: 'idle' | 'loading' | 'succeeded' | 'failed';
+        page: number;
+        lastPage: number;
+        onLoadMore: () => void;
+        threshold?: number;
+        rootMargin?: string;
+    };
+}

package/dist/components/Select/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './Select';
+export type { SelectProps, SelectOption } from './Select.types';

package/dist/components/SelectField/SelectField.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { SelectFieldProps } from './SelectField.types';
+declare const SelectField: React.ForwardRefExoticComponent<SelectFieldProps & React.RefAttributes<HTMLDivElement>>;
+export default SelectField;

package/dist/components/SelectField/SelectField.types.d.ts

@@ -0,0 +1,35 @@
+import React from 'react';
+export interface SelectFieldProps {
+    /** ID do campo */
+    id?: string;
+    /** Nome do campo */
+    name?: string;
+    /** Valor exibido */
+    value?: string;
+    /** Placeholder */
+    placeholder?: string;
+    /** Label do campo */
+    label?: string;
+    /** Texto de ajuda */
+    helperText?: string;
+    /** Mensagem de erro */
+    errorMessage?: string;
+    /** Campo obrigatório */
+    required?: boolean;
+    /** Campo desabilitado */
+    disabled?: boolean;
+    /** Ícone (chevron) */
+    icon?: React.ReactNode;
+    /** Estado aberto */
+    isOpen?: boolean;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** Tooltip info */
+    tooltip?: React.ReactNode;
+    tooltipText?: string;
+    positionTooltip?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'left' | 'right';
+    /** Indica se o campo foi "tocado" (aberto e fechado) */
+    isTouched?: boolean;
+    /** Força estado de erro independente da validação interna */
+    hasError?: boolean;
+}

package/dist/components/SelectRadix/SelectRadix.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { SelectRadixProps } from './SelectRadix.types';
+declare const SelectRadix: React.FC<SelectRadixProps>;
+export default SelectRadix;

package/dist/components/SelectRadix/SelectRadix.types.d.ts

@@ -0,0 +1,112 @@
+import { ReactNode } from 'react';
+export interface SelectItemProps {
+    id?: string;
+    text: ReactNode;
+    subTitle?: ReactNode;
+    icon?: ReactNode;
+    disabled?: boolean;
+    value: string;
+    selected?: boolean;
+}
+export interface CheckboxItemProps extends SelectItemProps {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+}
+export type SelectVariant = 'text' | 'icon' | 'checkbox';
+export interface SelectRadixProps {
+    items: SelectItemProps[];
+    onValueChange?: (value: string | string[]) => void;
+    onOpenChange?: (open: boolean) => void;
+    variant: SelectVariant;
+    required?: boolean;
+    value?: string | string[];
+    multiple?: boolean;
+    placeholder?: string;
+    search?: boolean;
+    tooltip?: boolean;
+    tooltipMessage?: string;
+    label?: string;
+    helperText?: string;
+    maxWidth?: string | number;
+    errorMessage?: string;
+    disabled?: boolean;
+    className?: string;
+    'aria-label'?: string;
+    'data-testid'?: string;
+    enableInfiniteScroll?: boolean;
+    onScrollEnd?: () => void;
+    isLoadingMore?: boolean;
+    enableApiSearch?: boolean;
+    onApiSearch?: (term: string) => void;
+    isSearching?: boolean;
+}
+export interface SelectState {
+    isOpen: boolean;
+    selectedValues: string[];
+    searchInput: string;
+    searchTerm: string;
+    touched: boolean;
+    hasError: boolean;
+}
+export type SelectAction = {
+    type: 'SET_OPEN';
+    payload: boolean;
+} | {
+    type: 'SET_SELECTED_VALUES';
+    payload: string[];
+} | {
+    type: 'SET_SEARCH_INPUT';
+    payload: string;
+} | {
+    type: 'SET_SEARCH_TERM';
+    payload: string;
+} | {
+    type: 'SET_TOUCHED';
+    payload: boolean;
+} | {
+    type: 'SET_ERROR';
+    payload: boolean;
+} | {
+    type: 'RESET_SEARCH';
+} | {
+    type: 'VALIDATE';
+    payload: {
+        required: boolean;
+    };
+};
+export interface UseSelectLogicProps {
+    value?: string | string[];
+    required?: boolean;
+    search?: boolean;
+    onValueChange?: (value: string | string[]) => void;
+    onOpenChange?: (open: boolean) => void;
+    enableApiSearch?: boolean;
+    onApiSearch?: (term: string) => void;
+    isSearching?: boolean;
+}
+export interface UseSelectLogicReturn {
+    state: SelectState;
+    actions: {
+        setOpen: (open: boolean) => void;
+        setSelectedValues: (values: string[]) => void;
+        setSearchInput: (input: string) => void;
+        setSearchTerm: (term: string) => void;
+        setTouched: (touched: boolean) => void;
+        setError: (error: boolean) => void;
+        resetSearch: () => void;
+        validate: () => void;
+        handleSingleSelect: (value: string) => void;
+        handleMultipleSelect: (value: string, checked: boolean) => void;
+    };
+    computed: {
+        displayText: string;
+        filteredItems: SelectItemProps[];
+    };
+    refs: {
+        searchInputRef: React.RefObject<HTMLInputElement | null>;
+    };
+    utils: {
+        getDisplayText: (selectedValues: string[], placeholder: string, variant: string, items: SelectItemProps[]) => string;
+        getFilteredItems: (items: SelectItemProps[], searchTerm: string) => SelectItemProps[];
+    };
+}

package/dist/components/SelectRadix/components/CheckboxSelectItem.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { CheckboxItemProps } from '../SelectRadix.types';
+declare const CheckboxSelectItem: React.FC<CheckboxItemProps>;
+export default CheckboxSelectItem;

package/dist/components/SelectRadix/components/SelectItem.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { SelectItemProps, SelectVariant } from '../SelectRadix.types';
+interface SelectItemComponentProps extends SelectItemProps {
+    variant?: SelectVariant;
+}
+declare const SelectItem: React.ForwardRefExoticComponent<SelectItemComponentProps & React.RefAttributes<HTMLDivElement>>;
+export default SelectItem;

package/dist/components/SelectRadix/hooks/useSelectLogic.d.ts

@@ -0,0 +1,3 @@
+import { UseSelectLogicProps, UseSelectLogicReturn } from '../SelectRadix.types';
+export declare function useSelectLogic({ value, required, search, onValueChange, onOpenChange, enableApiSearch, onApiSearch, isSearching, }: UseSelectLogicProps): UseSelectLogicReturn;
+export default useSelectLogic;

package/dist/components/SelectRadix/index.d.ts

@@ -0,0 +1,5 @@
+export { default } from './SelectRadix';
+export type { SelectRadixProps, SelectItemProps, CheckboxItemProps, SelectVariant, SelectState, SelectAction, UseSelectLogicProps, UseSelectLogicReturn } from './SelectRadix.types';
+export { useSelectLogic } from './hooks/useSelectLogic';
+export { default as CheckboxSelectItem } from './components/CheckboxSelectItem';
+export { default as SelectItem } from './components/SelectItem';

package/dist/components/Table/EmptyRows150Color.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+/**
+ * Componente de ícone SVG para estado vazio da tabela
+ * Exibe um ícone de lupa com design personalizado do Zanthus Design System
+ * @returns Elemento SVG para estado vazio
+ */
+declare const EmptyRows150Color: React.FC;
+export default EmptyRows150Color;

package/dist/components/Table/LoaderList.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { IContentLoaderProps } from 'react-content-loader';
+/**
+ * Componente de loading para lista de tabela
+ * Simula o carregamento de dados em formato de tabela usando ContentLoader
+ * @param props - Propriedades adicionais para o ContentLoader
+ * @returns Elemento de loading animado
+ */
+declare const LoaderList: React.FC<IContentLoaderProps>;
+export default LoaderList;

package/dist/components/Table/MultiLineText/MultiLineText.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+interface MultiLineTextProps {
+    /** Texto a ser exibido como linha principal */
+    text1: string;
+    /** Texto a ser exibido como linha secundária */
+    text2: string;
+}
+/**
+ * Componente para exibir texto em duas linhas
+ * Utilizado principalmente em tabelas para mostrar informações hierárquicas
+ */
+declare const MultiLineText: React.FC<MultiLineTextProps>;
+export default MultiLineText;
+export type { MultiLineTextProps };

package/dist/components/Table/MultiLineText/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './MultiLineText';
+export type { MultiLineTextProps } from './MultiLineText';

package/dist/components/Table/Table.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { TableProps } from './Table.types';
+declare const Table: React.FC<TableProps>;
+export default Table;

package/dist/components/Table/Table.types.d.ts

@@ -0,0 +1,35 @@
+import { ReactNode, CSSProperties } from 'react';
+export type TableColumnType = 'text' | 'datetime' | 'custom';
+export type TableAlign = 'left' | 'center' | 'right';
+export interface TableColumn {
+    key: string;
+    label: ReactNode;
+    type?: TableColumnType;
+    format?: string;
+    render?: (row: TableRowData, index: number) => ReactNode;
+    align?: TableAlign;
+    style?: CSSProperties;
+}
+export type TableRowData = Record<string, any>;
+export interface TableProps {
+    columns: TableColumn[];
+    dataSource: TableRowData[];
+    className?: string;
+    loading?: boolean;
+    rowSelection?: {
+        selectedRowKeys?: (string | number)[];
+        onChange?: (keys: (string | number)[], rows: TableRowData[]) => void;
+        getCheckboxProps?: (row: TableRowData, index: number) => {
+            disabled?: boolean;
+        };
+    };
+    locale?: {
+        emptyText?: ReactNode;
+    };
+    /** Eventos de linha */
+    onRow?: (row: TableRowData, index: number) => {
+        onClick?: () => void;
+        onDoubleClick?: () => void;
+        className?: string;
+    };
+}