@bluemarble/bm-components 2.5.2 → 2.6.0-rc

package/dist/index.d.cts

@@ -1,11 +1,13 @@
 import * as cookie from 'cookie';
-import * as React from 'react';
-import React__default, { PropsWithChildren, ReactNode, FC, Provider } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as _mui_material from '@mui/material';
-import { TableCellProps, TableCell, TextFieldProps, StandardTextFieldProps, SelectProps as SelectProps$1, FormControlProps, InputLabelProps, AutocompleteProps as AutocompleteProps$1, AutocompleteRenderInputParams, CheckboxProps as CheckboxProps$1, FormControlLabelProps, SwitchProps as SwitchProps$1, RadioGroupProps, ButtonProps, CircularProgressProps, Theme, SxProps, TableSortLabelProps, BoxProps, PaperProps, TableProps, TableHeadProps, TableBodyProps, ModalProps, DialogProps, StackProps, IconButtonProps, TypographyProps, AlertColor } from '@mui/material';
-import * as _mui_material_OverridableComponent from '@mui/material/OverridableComponent';
-import { FactoryOpts } from 'imask';
+import { AutocompleteProps as AutocompleteProps$1, AutocompleteRenderInputParams, TextFieldProps, StackProps, IconButtonProps, TypographyProps, ButtonProps, ModalProps, BoxProps, Theme, SxProps, TableCellProps, TableSortLabelProps, PaperProps, TableProps, TableHeadProps, TableBodyProps, CheckboxProps as CheckboxProps$1, FormControlLabelProps, DialogProps, TableCell, StandardTextFieldProps, CircularProgressProps, RadioGroupProps, SelectProps as SelectProps$1, FormControlProps, InputLabelProps, SwitchProps as SwitchProps$1, AlertColor } from '@mui/material';
+import * as React from 'react';
+import React__default, { ReactNode, PropsWithChildren, FC, Provider } from 'react';
+import EditorJS, { BlockAPI, OutputData, OutputBlockData, EditorConfig, ToolConstructable, ToolSettings, API, BlockMutationEvent } from '@editorjs/editorjs';
 import { IconType } from 'react-icons';
+import { FactoryOpts } from 'imask';
+import * as _mui_material_OverridableComponent from '@mui/material/OverridableComponent';
 import { AxiosInstance } from 'axios';
 import { ZodSchema } from 'zod';
 
@@ -56,111 +58,6 @@ declare const nookies: {
     destroy: typeof destroyCookie;
 };
 
-/** @deprecated Use {@link ColumnsProps} from `BaseGrid` instead. */
-interface ColumnTitleProps {
-    name: string;
-    label: string;
-    transformer?: (value: string | number | Date) => string;
-    sx?: TableCellProps['sx'];
-}
-/** @deprecated Use {@link FilterProps} from `useFilter` instead. */
-interface FilterProps$1 {
-    column: string;
-    value: string;
-    transformer?: (value: string | number | Date) => string;
-}
-/** @deprecated Use {@link FilterProps} from `useFilter` instead. */
-type IFilter = FilterProps$1;
-/** @deprecated */
-interface GridProps$1<T> {
-    columnTitles: ColumnTitleProps[];
-    defaultData: T[];
-    tableData: T[];
-    selectedFilters: FilterProps$1[];
-    setSelectedFilters(value: FilterProps$1[]): void;
-    setTableData(value: T[]): void;
-    updateFilters(value: Record<string, any>[]): void;
-    rowOptions?: number[];
-    footer?: ReactNode;
-    customButtons?: ReactNode;
-    isLoading?: boolean;
-    noFilterButtons?: boolean;
-    noPagination?: boolean;
-    noFilters?: boolean;
-    primaryKey?: string;
-}
-/**
- * @deprecated Use {@link BaseGrid} with the {@link useGrid} or {@link useAsyncGrid} hook instead.
- * `BaseGrid` separates rendering from state management, eliminating the need to pass
- * `tableData`, `setTableData`, `selectedFilters`, and `updateFilters` as props.
- */
-declare const Grid: <ObjectType>(props: PropsWithChildren<GridProps$1<ObjectType>>) => React__default.JSX.Element;
-
-/** @deprecated Use the `useFilter` hook instead. */
-declare function filterData<T>(filters: FilterProps$1[], defaultData: {
-    current: T[];
-}): T[];
-
-/** @deprecated Use `TableRow` from `@mui/material` directly. */
-declare const Tr: _mui_material_OverridableComponent.OverridableComponent<_mui_material.TableRowTypeMap<{}, "tr">>;
-
-/** @deprecated Use `TableCell` from `@mui/material` directly. */
-declare const Td: typeof TableCell;
-
-interface EditableTableCellProps extends TableCellProps {
-    name: string;
-    TextFieldProps?: TextFieldProps;
-    type?: TextFieldProps['type'];
-    fullWidth?: boolean;
-    rowData?: Record<string, any>;
-    mask?: FactoryOpts;
-    bordered?: boolean;
-    rowIndex?: string | number;
-    formatCellValue?: (value: string) => string;
-    formatInputDefautvalue?: (value: string) => string;
-    onSave?: (props: OnSaveProps) => void;
-    onCancel?: () => void;
-}
-interface OnSaveProps {
-    name: string;
-    event: FocusEvent;
-    value: string;
-    data: Record<string, any>;
-}
-declare const EditableTableCell: (allProps: EditableTableCellProps) => React__default.JSX.Element;
-
-interface InputProps extends StandardTextFieldProps {
-    name: string;
-    label: string;
-    shrink?: boolean;
-    withFormik?: boolean;
-}
-declare const Input: FC<InputProps>;
-
-interface InputMaskProps extends Partial<StandardTextFieldProps> {
-    name: string;
-    label: string;
-    withFormik?: boolean;
-    value?: string;
-    mask: FactoryOpts;
-    onChangeValue?: (value: string, unmaskedValue: string) => void;
-}
-declare function InputMask({ withFormik, ...rest }: InputMaskProps): React__default.JSX.Element;
-
-interface CustomInputLabelProps extends InputLabelProps {
-    size?: 'small';
-}
-type MuiSelectPropsWithouVariant<T> = Omit<SelectProps$1<T>, 'variant'>;
-type SelectProps<T> = MuiSelectPropsWithouVariant<T> & {
-    name: string;
-    label: string;
-    withFormik?: boolean;
-    FormControlProps?: Partial<FormControlProps>;
-    InputLabelProps?: Partial<CustomInputLabelProps>;
-    helperText?: string;
-};
-declare function Select<T>({ withFormik, helperText, ...rest }: SelectProps<T>): React__default.JSX.Element;
-
 type MuiAutocompleteBaseProps<T> = Omit<AutocompleteProps$1<T, boolean, undefined, boolean>, 'renderInput' | 'getOptionLabel'>;
 interface AutocompleteWithoutProps<T> extends MuiAutocompleteBaseProps<T> {
     name?: never;
@@ -188,99 +85,92 @@ interface AutocompleteWithFormikProps<T> extends MuiAutocompleteBaseProps<T> {
     getOptionValue?: (option: T) => string | number;
 }
 type AutocompleteProps<T> = AutocompleteWithoutProps<T> | AutocompleteWithFormikProps<T>;
-declare function Autocomplete<T>({ withFormik, name, getOptionValue, ...rest }: AutocompleteProps<T>): React__default.JSX.Element;
+declare function Autocomplete<T>({ withFormik, name, getOptionValue, ...rest }: AutocompleteProps<T>): react_jsx_runtime.JSX.Element;
 
-type CheckboxProps = CheckboxWithFormik | CheckboxWithoutFormik;
-interface CheckboxWithFormik extends CheckboxProps$1 {
-    name: string;
-    label?: string;
-    helperText?: string;
-    withFormik?: true;
-    FormControlLabelProps?: Partial<FormControlLabelProps>;
-}
-interface CheckboxWithoutFormik extends CheckboxProps$1 {
-    name?: never;
-    label?: string;
-    helperText?: string;
-    withFormik: false;
-    FormControlLabelProps?: Partial<FormControlLabelProps>;
+interface DialogHeaderProps extends StackProps {
+    title: string;
+    IconButtonProps?: IconButtonProps;
+    TypographyProps?: TypographyProps;
+    onClose?: () => void;
 }
-declare const Checkbox: ({ withFormik, name, ...props }: CheckboxProps) => React__default.JSX.Element;
 
-type SwitchProps = SwitchWithFormik | SwitchWithoutFormik;
-interface SwitchWithFormik extends SwitchProps$1 {
-    name: string;
-    label?: string;
-    helperText?: string;
-    withFormik?: true;
-    FormControlLabelProps?: Partial<FormControlLabelProps>;
-}
-interface SwitchWithoutFormik extends SwitchProps$1 {
-    name?: never;
-    label?: string;
-    helperText?: string;
-    withFormik: false;
-    FormControlLabelProps?: Partial<FormControlLabelProps>;
+interface IBaseDialogContext {
+    opened: symbol[];
+    isOpened(dialog: symbol): boolean;
+    toggle(dialog: symbol): boolean;
+    open(dialog: symbol): void;
+    close(dialog: symbol): void;
+    closeAll(): void;
 }
-declare const Switch: ({ withFormik, name, ...props }: SwitchProps) => React__default.JSX.Element;
 
-type RadioOptionProps = {
-    value: string | number | boolean;
-    label: string;
+declare function useBaseDialog(): IBaseDialogContext;
+declare function useBaseDialogInstance(): {
+    name: symbol;
+    actions: ReturnType<typeof useBaseDialog>;
 };
-type RadioOptionsProps = RadioWithFormik | RadioWithoutFormik;
-interface RadioWithFormik extends RadioGroupProps {
-    name: string;
-    label?: string;
-    options: RadioOptionProps[];
-    helperText?: string;
-    withFormik?: true;
-}
-interface RadioWithoutFormik extends RadioGroupProps {
-    name?: never;
-    label?: string;
-    options: RadioOptionProps[];
-    helperText?: string;
-    withFormik: false;
-}
-declare const Radio: ({ name, withFormik, ...rest }: RadioOptionsProps) => React__default.JSX.Element;
 
-interface LargeButtonProps extends ButtonProps {
-    loading?: boolean;
-    children: ReactNode;
-    CircularProgressProps?: CircularProgressProps;
+interface IBaseDialogInstanceProviderProps {
+    children: React__default.ReactNode;
+    name: symbol;
 }
-declare const LargeButton: ({ loading, children, CircularProgressProps, sx, ...rest }: LargeButtonProps) => React__default.JSX.Element;
 
-declare function getTabProps(index: string): {
-    id: string;
-    'aria-controls': string;
-};
-interface TabPanelProps {
-    children: React__default.ReactNode;
-    value: number;
-    index: number;
+interface IBaseDialogContainerProps extends Omit<Partial<ModalProps>, 'open' | 'children'> {
+    BoxProps?: BoxProps;
+    children: React__default.ReactNode | ((props: {
+        close: () => void;
+    }) => React__default.ReactNode);
+}
+declare const BaseDialogContainer: ({ children, BoxProps, ...rest }: IBaseDialogContainerProps) => react_jsx_runtime.JSX.Element;
+interface IBaseDialogBodyProps extends BoxProps {
+}
+declare const BaseDialogBody: (props: IBaseDialogBodyProps) => react_jsx_runtime.JSX.Element;
+interface IBaseDialogTriggerProps extends Omit<ButtonProps, 'name'> {
+    name: symbol;
 }
-declare const TabPanel: (props: TabPanelProps) => React__default.JSX.Element;
+declare const BaseDialogTrigger: ({ name, onClick, ...props }: IBaseDialogTriggerProps) => react_jsx_runtime.JSX.Element;
+declare const BaseDialogCreate: (name?: symbol) => {
+    name: symbol;
+    Trigger: (props: Omit<IBaseDialogTriggerProps, "name">) => react_jsx_runtime.JSX.Element;
+    Root: (props: Omit<IBaseDialogInstanceProviderProps, "name">) => react_jsx_runtime.JSX.Element;
+    Container: ({ children, BoxProps, ...rest }: IBaseDialogContainerProps) => react_jsx_runtime.JSX.Element;
+    Header: ({ title, onClose, IconButtonProps, TypographyProps, ...props }: DialogHeaderProps) => react_jsx_runtime.JSX.Element;
+    Body: (props: IBaseDialogBodyProps) => react_jsx_runtime.JSX.Element;
+};
+declare const BaseDialog: {
+    Create: (name?: symbol) => {
+        name: symbol;
+        Trigger: (props: Omit<IBaseDialogTriggerProps, "name">) => react_jsx_runtime.JSX.Element;
+        Root: (props: Omit<IBaseDialogInstanceProviderProps, "name">) => react_jsx_runtime.JSX.Element;
+        Container: ({ children, BoxProps, ...rest }: IBaseDialogContainerProps) => react_jsx_runtime.JSX.Element;
+        Header: ({ title, onClose, IconButtonProps, TypographyProps, ...props }: DialogHeaderProps) => react_jsx_runtime.JSX.Element;
+        Body: (props: IBaseDialogBodyProps) => react_jsx_runtime.JSX.Element;
+    };
+    Trigger: ({ name, onClick, ...props }: IBaseDialogTriggerProps) => react_jsx_runtime.JSX.Element;
+    Provider: (props: any) => react_jsx_runtime.JSX.Element;
+    Root: (props: IBaseDialogInstanceProviderProps) => react_jsx_runtime.JSX.Element;
+    Container: ({ children, BoxProps, ...rest }: IBaseDialogContainerProps) => react_jsx_runtime.JSX.Element;
+    Header: ({ title, onClose, IconButtonProps, TypographyProps, ...props }: DialogHeaderProps) => react_jsx_runtime.JSX.Element;
+    Body: (props: IBaseDialogBodyProps) => react_jsx_runtime.JSX.Element;
+};
 
 type FilterCompareType = 'gte' | 'lte' | 'lt' | 'gt' | 'equal' | 'valueIn' | 'in' | 'notEqual' | 'valueNotIn' | 'notIn';
-type FilterProps = {
+type FilterProps$1 = {
     id?: string;
     prop: string;
     value: unknown;
     compareType: FilterCompareType;
 };
 interface IUseFilterProps {
-    defaultFilters?: FilterProps[];
+    defaultFilters?: FilterProps$1[];
 }
 declare function useFilter(props?: IUseFilterProps): {
-    filters: FilterProps[];
-    filterBy: (newFilter: FilterProps) => void;
+    filters: FilterProps$1[];
+    filterBy: (newFilter: FilterProps$1) => void;
     removeFilter: (prop: string, isId?: boolean) => void;
     createFilter: typeof createFilter;
     clearAllFilters: () => void;
 };
-declare function createFilter<T extends Record<string, any>>(filters: FilterProps[]): {
+declare function createFilter<T extends Record<string, any>>(filters: FilterProps$1[]): {
     apply: (item: T) => boolean;
 };
 
@@ -298,7 +188,7 @@ interface SearchOptions$1 {
 }
 interface UseGridProps$1<T> {
     columns: ColumnsProps[];
-    filters?: FilterProps[];
+    filters?: FilterProps$1[];
     rowsPerPageOptions?: number[];
     search?: SearchOptions$1;
     defaultCurrentPage?: number;
@@ -334,7 +224,7 @@ interface ColumnsProps<T extends object = Theme> {
     canSort?: boolean;
     children?: ReactNode;
 }
-interface GridProps {
+interface GridProps$1 {
     columns: ColumnsProps[];
     children: ReactNode;
     prependColumn?: ReactNode;
@@ -361,30 +251,787 @@ interface GridProps {
     isLoading?: boolean;
     hideFooter?: boolean;
 }
-declare function BaseGrid({ columns, children, paperProps, tableBodyProps, tableHeadProps, tableProps, sortedBy, onSortBy, dense, striped, bordered, currentPage, totalNumberOfPages, tableSortLabelProps, boxContainerProps, onPageChange, rowsPerPage, setRowsPerPage, rowsPerPageOptions, hideFooter, prependColumn, appendColumn, loadingColSpan, isLoading }: GridProps): React__default.JSX.Element;
+declare function BaseGrid({ columns, children, paperProps, tableBodyProps, tableHeadProps, tableProps, sortedBy, onSortBy, dense, striped, bordered, currentPage, totalNumberOfPages, tableSortLabelProps, boxContainerProps, onPageChange, rowsPerPage, setRowsPerPage, rowsPerPageOptions, hideFooter, prependColumn, appendColumn, loadingColSpan, isLoading }: GridProps$1): react_jsx_runtime.JSX.Element;
 
 interface BaseGridAutoRowsProps<T> {
     columns: ColumnsProps<any>[];
     data: T[];
     rowKey: keyof T;
 }
-declare function BaseGridAutoRows<T>({ data, columns, rowKey }: BaseGridAutoRowsProps<T>): React__default.JSX.Element;
+declare function BaseGridAutoRows<T>({ data, columns, rowKey }: BaseGridAutoRowsProps<T>): react_jsx_runtime.JSX.Element;
+
+/** Formato salvo: { alignment } — compatível com editorjs-text-alignment-blocktune */
+type AlignmentData = {
+    alignment: Alignment;
+};
+type Alignment = 'left' | 'center' | 'right';
+declare class AlignmentTune {
+    private api;
+    private block;
+    private config;
+    private data;
+    private wrapper;
+    static get isTune(): boolean;
+    static get DEFAULT_ALIGNMENT(): Alignment;
+    constructor({ api, data, config, block }: any);
+    private defaultAlignment;
+    wrap(blockContent: HTMLElement): HTMLElement;
+    render(): {
+        icon: string;
+        title: string;
+        name: string;
+        toggle: string;
+        isActive: boolean;
+        onActivate: () => void;
+    }[];
+    private setAlignment;
+    save(): AlignmentData;
+}
+
+/** Formato salvo: { file, title } — compatível com @editorjs/attaches */
+type AttachesData = {
+    file: Record<string, any>;
+    title: string;
+};
+declare class Attaches {
+    private api;
+    private block;
+    private readOnly;
+    private config;
+    private data;
+    private wrapper;
+    private titleField;
+    static get isReadOnlySupported(): boolean;
+    static get toolbox(): {
+        icon: string;
+        title: string;
+    };
+    static get sanitize(): {
+        title: {};
+        file: boolean;
+    };
+    /**
+     * Recebe qualquer arquivo colado que não seja imagem — o editor casa o mime type
+     * pelo tipo principal, então listar todos menos `image/*` evita conflito com o plugin de imagem.
+     */
+    static get pasteConfig(): {
+        files: {
+            mimeTypes: string[];
+        };
+    };
+    constructor({ data, config, api, block, readOnly }: any);
+    render(): HTMLElement;
+    private drawView;
+    private getExtension;
+    private createUploadButton;
+    private selectFile;
+    /** Sem `config.uploader.uploadByFile` o arquivo fica local (data URL + buffer). */
+    private upload;
+    onPaste(event: any): Promise<void>;
+    validate(data: AttachesData): boolean;
+    save(): AttachesData;
+}
+
+/** Formato salvo: { items: [{ text, checked }] } — compatível com @editorjs/checklist */
+type ChecklistData = {
+    items: {
+        text: string;
+        checked: boolean;
+    }[];
+};
+declare class Checklist {
+    private api;
+    private readOnly;
+    private data;
+    private wrapper;
+    static get isReadOnlySupported(): boolean;
+    static get enableLineBreaks(): boolean;
+    static get toolbox(): {
+        icon: string;
+        title: string;
+    };
+    static get sanitize(): {
+        items: {
+            text: {};
+            checked: boolean;
+        };
+    };
+    static get conversionConfig(): {
+        export: (data: ChecklistData) => string;
+        import: (text: string) => {
+            items: {
+                text: string;
+                checked: boolean;
+            }[];
+        };
+    };
+    constructor({ data, api, readOnly }: any);
+    render(): HTMLElement;
+    private createItem;
+    private onKeyDown;
+    private appendItem;
+    /** Item vazio + Enter: sai da lista criando um parágrafo abaixo. */
+    private leaveList;
+    private onBackspace;
+    save(): ChecklistData;
+}
+
+/** Formato salvo: { code } — compatível com @editorjs/code */
+type CodeData = {
+    code: string;
+};
+declare class Code {
+    private readOnly;
+    private placeholder;
+    private data;
+    private textarea;
+    static get isReadOnlySupported(): boolean;
+    static get enableLineBreaks(): boolean;
+    static get toolbox(): {
+        icon: string;
+        title: string;
+    };
+    static get sanitize(): {
+        code: boolean;
+    };
+    static get pasteConfig(): {
+        tags: string[];
+    };
+    static get conversionConfig(): {
+        export: string;
+        import: string;
+    };
+    constructor({ data, config, readOnly }: any);
+    render(): HTMLTextAreaElement;
+    rendered(): void;
+    private resize;
+    onPaste(event: any): void;
+    save(): CodeData;
+}
+
+/**
+ * Permite reordenar blocos arrastando o botão de configurações da toolbar.
+ * Substitui o editorjs-drag-drop.
+ *
+ * Blocos aninhados (@see nesting) viajam com o bloco arrastado: a subárvore é
+ * movida inteira e o recuo é recalculado a partir do alvo — soltar abaixo de um
+ * toggle aberto adota o bloco como filho dele, e soltar na raiz o desaninha.
+ */
+declare class DragDrop {
+    private api;
+    private toolbar;
+    private holder;
+    private startBlock;
+    private dropBlock;
+    private subtree;
+    private observer;
+    /** `color` pinta o bloco arrastado e a linha do destino. */
+    constructor(editor: EditorJS, holder?: HTMLElement, color?: string);
+    destroy(): void;
+    /** O botão de configurações só existe depois que a toolbar é montada. */
+    private watchSettingsButton;
+    private initializeDragListener;
+    private getBlocks;
+    /**
+     * O alvo vem da posição do ponteiro, e não da classe `ce-block--drop-target`
+     * do editor: ela sobrevive ao `dragleave` em alguns casos e deixava mais de
+     * um bloco com a linha visível ao mesmo tempo.
+     */
+    private onDragOver;
+    /** A linha fica sempre abaixo do bloco sob o cursor. */
+    private highlightTarget;
+    private clearHighlight;
+    private onDrop;
+    /** Quantos blocos seguintes ao alvo estão escondidos por ele (toggle fechado). */
+    private getHiddenLength;
+    /**
+     * Solto abaixo de um toggle aberto o bloco vira o primeiro filho dele; nos
+     * demais casos ele assume o mesmo nível do alvo.
+     */
+    private reparent;
+}
+
+/** Formato salvo: { text, level } — compatível com @editorjs/header */
+type HeaderData = {
+    text: string;
+    level: number;
+};
+declare class Header {
+    private api;
+    private block;
+    private readOnly;
+    private placeholder;
+    private defaultLevel;
+    private element;
+    private data;
+    static get isReadOnlySupported(): boolean;
+    static get toolbox(): {
+        icon: string;
+        title: string;
+    };
+    static get conversionConfig(): {
+        export: string;
+        import: string;
+    };
+    static get sanitize(): {
+        level: boolean;
+        text: {};
+    };
+    static get pasteConfig(): {
+        tags: string[];
+    };
+    constructor({ data, config, api, block, readOnly }: any);
+    render(): HTMLElement;
+    private drawView;
+    renderSettings(): {
+        icon: string;
+        title: string;
+        name: string;
+        toggle: string;
+        isActive: boolean;
+        onActivate: () => void;
+    }[];
+    private setLevel;
+    merge(data: HeaderData): void;
+    save(element: HTMLElement): HeaderData;
+    onPaste(event: any): void;
+}
+
+/**
+ * Ícones dos plugins.
+ *
+ * O Editor.js espera uma string de html, então os componentes do `react-icons`
+ * são serializados para svg uma única vez (sem `react-dom/server`).
+ * Use `iconToHtml` para trocar qualquer ícone por outro do `react-icons`.
+ */
+
+/** Converte um ícone do `react-icons` em html, no formato aceito pelo Editor.js. */
+declare function iconToHtml(icon: IconType, size?: number | string): string;
+declare const icons: {
+    header: string;
+    headerLevel: (level: number) => string;
+    listUnordered: string;
+    listOrdered: string;
+    checklist: string;
+    table: string;
+    code: string;
+    image: string;
+    attaches: string;
+    underline: string;
+    strikethrough: string;
+    alignLeft: string;
+    alignCenter: string;
+    alignRight: string;
+    callOut: string;
+    citation: string;
+    details: string;
+    toggle: string;
+    row: string;
+    column: string;
+    plus: string;
+    trash: string;
+    stretch: string;
+    border: string;
+    caption: string;
+    background: string;
+};
+type Icons = typeof icons;
+
+/**
+ * Formato salvo: { file, caption, withBorder, withBackground, stretched } — compatível com @editorjs/image.
+ * `withCaption` é um campo extra (controla a exibição da legenda) e é opcional na leitura.
+ */
+type ImageData = {
+    file: Record<string, any>;
+    caption: string;
+    withBorder: boolean;
+    withBackground: boolean;
+    stretched: boolean;
+    withCaption: boolean;
+};
+declare class Image {
+    private api;
+    private block;
+    private readOnly;
+    private config;
+    private data;
+    private wrapper;
+    private captionField;
+    static get isReadOnlySupported(): boolean;
+    static get toolbox(): {
+        icon: string;
+        title: string;
+    };
+    static get sanitize(): {
+        caption: {};
+        file: boolean;
+        withBorder: boolean;
+        withBackground: boolean;
+        stretched: boolean;
+        withCaption: boolean;
+    };
+    static get pasteConfig(): {
+        tags: string[];
+        files: {
+            mimeTypes: string[];
+        };
+    };
+    constructor({ data, config, api, block, readOnly }: any);
+    render(): HTMLElement;
+    rendered(): void;
+    private drawView;
+    private createUploadButton;
+    private selectFile;
+    /** Sem `config.uploader.uploadByFile` o arquivo fica local (data URL + buffer). */
+    private upload;
+    private stretch;
+    renderSettings(): {
+        icon: string;
+        title: string;
+        name: string;
+        toggle: boolean;
+        isActive: boolean;
+        onActivate: () => void;
+    }[];
+    private toggleTune;
+    private getCaption;
+    onPaste(event: any): Promise<void>;
+    validate(data: ImageData): boolean;
+    save(): ImageData;
+}
+
+/** Formato salvo: { style, items: string[] } — compatível com @editorjs/list v1 */
+type ListData = {
+    style: 'ordered' | 'unordered';
+    items: string[];
+};
+declare class List {
+    private api;
+    private block;
+    private readOnly;
+    private data;
+    private wrapper;
+    static get isReadOnlySupported(): boolean;
+    static get enableLineBreaks(): boolean;
+    static get toolbox(): {
+        icon: string;
+        title: string;
+        data: {
+            style: string;
+        };
+    }[];
+    static get conversionConfig(): {
+        export: (data: ListData) => string;
+        import: (text: string) => {
+            items: string[];
+            style: string;
+        };
+    };
+    static get sanitize(): {
+        style: boolean;
+        items: {
+            br: boolean;
+        };
+    };
+    static get pasteConfig(): {
+        tags: string[];
+    };
+    constructor({ data, api, block, readOnly }: any);
+    render(): HTMLElement;
+    private drawView;
+    private onEnter;
+    renderSettings(): {
+        icon: string;
+        title: string;
+        name: string;
+        toggle: string;
+        isActive: boolean;
+        onActivate: () => void;
+    }[];
+    private setStyle;
+    private getItems;
+    onPaste(event: any): void;
+    save(): ListData;
+}
+
+/** Inline tool que gera <s class="cdx-strikethrough"> — compatível com @sotaproject/strikethrough */
+declare class Strikethrough {
+    private api;
+    private button;
+    static get isInline(): boolean;
+    static get title(): string;
+    static get sanitize(): {
+        s: {
+            class: string;
+        };
+    };
+    get shortcut(): string;
+    constructor({ api }: any);
+    render(): HTMLButtonElement;
+    surround(range: Range): void;
+    private wrap;
+    private unwrap;
+    checkState(): boolean;
+}
+
+/** Formato salvo: { withHeadings, content: string[][] } — compatível com @editorjs/table */
+type TableData = {
+    withHeadings: boolean;
+    content: string[][];
+};
+declare class Table {
+    private api;
+    private block;
+    private readOnly;
+    private data;
+    private wrapper;
+    private table;
+    private selectedCell;
+    static get isReadOnlySupported(): boolean;
+    static get enableLineBreaks(): boolean;
+    static get toolbox(): {
+        icon: string;
+        title: string;
+    };
+    static get sanitize(): {
+        withHeadings: boolean;
+        content: {
+            br: boolean;
+        };
+    };
+    constructor({ data, config, api, block, readOnly }: any);
+    private emptyContent;
+    render(): HTMLElement;
+    private drawTable;
+    private createCell;
+    private onKeyDown;
+    private getPosition;
+    private moveTo;
+    private focusCell;
+    /** Índice da linha/coluna em foco (última linha/coluna quando nada estiver selecionado). */
+    private currentPosition;
+    private addRow;
+    private addColumn;
+    private deleteRow;
+    private deleteColumn;
+    private toggleHeadings;
+    renderSettings(): ({
+        icon: string;
+        title: string;
+        name: string;
+        toggle: boolean;
+        isActive: boolean;
+        onActivate: () => void;
+    } | {
+        icon: string;
+        title: string;
+        name: string;
+        onActivate: () => void;
+        toggle?: undefined;
+        isActive?: undefined;
+    })[];
+    private getContent;
+    save(): TableData;
+}
+
+/** Formato salvo: string ('' | 'call-out' | 'citation' | 'details') — compatível com @editorjs/text-variant-tune */
+type TextVariant = '' | 'call-out' | 'citation' | 'details';
+declare class TextVariantTune {
+    private api;
+    private block;
+    private data;
+    private wrapper;
+    static get isTune(): boolean;
+    constructor({ api, data, block }: any);
+    wrap(blockContent: HTMLElement): HTMLElement;
+    render(): {
+        icon: string;
+        title: string;
+        name: string;
+        toggle: string;
+        isActive: boolean;
+        onActivate: () => void;
+    }[];
+    private setVariant;
+    save(): "" | "details" | "call-out" | "citation";
+}
+
+/** Formato salvo: { text, status, fk, items } — compatível com editorjs-toggle-block. */
+type ToggleData = {
+    text: string;
+    status: 'open' | 'closed';
+    fk: string;
+    items: number;
+};
+/**
+ * Os "filhos" do toggle são os blocos seguintes (a quantidade fica em `items`),
+ * apenas escondidos quando o toggle está fechado. Arrastar o toggle leva a
+ * subárvore junto (@see dragDrop).
+ */
+declare class ToggleBlock {
+    private api;
+    private readOnly;
+    private placeholder;
+    private data;
+    private wrapper;
+    private input;
+    private icon;
+    private empty;
+    private redactor;
+    private adopted;
+    /** @internal usado pelo controlador de teclado */
+    block: BlockAPI;
+    static get isReadOnlySupported(): boolean;
+    static get enableLineBreaks(): boolean;
+    static get toolbox(): {
+        icon: string;
+        title: string;
+    };
+    static get sanitize(): {
+        text: {};
+        status: boolean;
+        fk: boolean;
+        items: boolean;
+    };
+    constructor({ data, config, api, block, readOnly }: any);
+    render(): HTMLElement;
+    /** Os blocos irmãos só existem depois que o editor termina de renderizar. */
+    rendered(): void;
+    destroy(): void;
+    private get index();
+    private get depth();
+    /**
+     * Ao carregar um conteúdo salvo os filhos são apenas os `items` blocos
+     * seguintes; a partir daí o vínculo vive no dataset, o que mantém a
+     * contagem correta mesmo se algum bloco for removido.
+     *
+     * Toggles aninhados renderizam depois do pai e reescrevem a marcação dos
+     * próprios filhos, aprofundando o nível.
+     */
+    private adopt;
+    /** Devolve os filhos diretos ao avô — usado quando o toggle é removido. */
+    private releaseChildren;
+    /** @internal reaplica visibilidade/contagem; os aninhados reaplicam o próprio estado. */
+    sync(): void;
+    /** @internal */
+    isCollapsed(): boolean;
+    /** @internal */
+    expand(): void;
+    /** @internal marca o editor como alterado após uma mudança estrutural. */
+    touch(): void;
+    private setStatus;
+    /** Enter (ou clique no item vazio) cria um filho e leva o cursor até ele. */
+    private createChild;
+    save(): ToggleData;
+}
+
+/** Inline tool que gera <u> — compatível com @editorjs/underline */
+declare class Underline {
+    private api;
+    private button;
+    static get isInline(): boolean;
+    static get title(): string;
+    static get sanitize(): {
+        u: {};
+    };
+    get shortcut(): string;
+    constructor({ api }: any);
+    render(): HTMLButtonElement;
+    surround(): void;
+    checkState(): boolean;
+}
 
-type TModalProps = {
-    open: boolean;
-    onClose: () => void;
-    children: React__default.ReactNode;
-    BoxProps?: BoxProps;
-} & Omit<ModalProps, 'children'>;
 /**
- * @deprecated Use `Dialog` or `BaseDialog` instead. `Modal` will be removed in a future release.
+ * Histórico de desfazer/refazer (CMD/CTRL+Z e CMD/CTRL+Y).
+ *
+ * O `onChange` do editor é debounced em 400ms e o timer reinicia a cada mutação,
+ * ou seja: enquanto se digita sem parar ele nunca dispara e o parágrafo inteiro
+ * vira um único ponto de histórico. Por isso aqui o gatilho principal é o
+ * `beforeinput` do holder (síncrono) e o `onChange` entra só como reforço para
+ * mudanças que não passam pelo teclado (tunes, tabela, upload, drag&drop).
  */
-declare const Modal: ({ open, onClose, BoxProps, ...rest }: TModalProps) => React__default.JSX.Element;
+declare class Undo {
+    private editor;
+    private holder;
+    private maxLength;
+    private stack;
+    private position;
+    /** Último estado conhecido da tela, usado como base do diff. */
+    private lastSnapshot;
+    private timer;
+    private burstStart;
+    private caretBefore;
+    private muteUntil;
+    private destroyed;
+    /** Serializa saves/renders para que nada resolva fora de ordem. */
+    private chain;
+    constructor(editor: EditorJS, holder?: HTMLElement, maxLength?: number);
+    destroy(): void;
+    /** Define o estado inicial (evita desfazer para um editor vazio). */
+    initialize(data?: OutputData | OutputBlockData[]): void;
+    clear(): void;
+    /** Chamado pelo onChange do editor (tunes, tabela, upload, mover bloco...). */
+    registerChange(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): void;
+    redo(): void;
+    private reset;
+    private enqueue;
+    private onBeforeInput;
+    private onStructuralEvent;
+    /**
+     * Marca que houve edição. O primeiro toque de um burst guarda o cursor de
+     * antes da alteração; os seguintes só empurram o timer.
+     */
+    private touch;
+    /** Fecha o burst na pausa, mas nunca depois de MAX_BURST. */
+    private schedule;
+    private commit;
+    /** Antecipa um burst ainda pendente (usado antes de desfazer/refazer). */
+    private flushPending;
+    private snapshot;
+    private push;
+    private apply;
+    /**
+     * Atualiza só os blocos que mudaram. Um `blocks.render()` recria o documento
+     * inteiro (lento e perde o foco), então ele fica como fallback para quando a
+     * lista de blocos muda de tamanho, ordem ou tipo.
+     */
+    private patch;
+    private getCaret;
+    private setCaret;
+    private indexOf;
+    /** Reposiciona o cursor pelo offset de texto dentro do bloco. */
+    private applyOffset;
+    private onKeyDown;
+}
 
-declare function GetInputLabel<T extends Array<Record<string, any>>, K extends T[number]['name']>(columns: T): (columnName: K) => {
-    label: any;
-    name: any;
+type index_AlignmentData = AlignmentData;
+type index_AlignmentTune = AlignmentTune;
+declare const index_AlignmentTune: typeof AlignmentTune;
+type index_Attaches = Attaches;
+declare const index_Attaches: typeof Attaches;
+type index_AttachesData = AttachesData;
+type index_Checklist = Checklist;
+declare const index_Checklist: typeof Checklist;
+type index_ChecklistData = ChecklistData;
+type index_Code = Code;
+declare const index_Code: typeof Code;
+type index_CodeData = CodeData;
+type index_DragDrop = DragDrop;
+declare const index_DragDrop: typeof DragDrop;
+type index_Header = Header;
+declare const index_Header: typeof Header;
+type index_HeaderData = HeaderData;
+type index_Icons = Icons;
+type index_Image = Image;
+declare const index_Image: typeof Image;
+type index_ImageData = ImageData;
+type index_List = List;
+declare const index_List: typeof List;
+type index_ListData = ListData;
+type index_Strikethrough = Strikethrough;
+declare const index_Strikethrough: typeof Strikethrough;
+type index_Table = Table;
+declare const index_Table: typeof Table;
+type index_TableData = TableData;
+type index_TextVariant = TextVariant;
+type index_TextVariantTune = TextVariantTune;
+declare const index_TextVariantTune: typeof TextVariantTune;
+type index_ToggleBlock = ToggleBlock;
+declare const index_ToggleBlock: typeof ToggleBlock;
+type index_ToggleData = ToggleData;
+type index_Underline = Underline;
+declare const index_Underline: typeof Underline;
+type index_Undo = Undo;
+declare const index_Undo: typeof Undo;
+declare const index_iconToHtml: typeof iconToHtml;
+declare const index_icons: typeof icons;
+declare namespace index {
+  export { type index_AlignmentData as AlignmentData, index_AlignmentTune as AlignmentTune, index_Attaches as Attaches, type index_AttachesData as AttachesData, index_Checklist as Checklist, type index_ChecklistData as ChecklistData, index_Code as Code, type index_CodeData as CodeData, index_DragDrop as DragDrop, index_Header as Header, type index_HeaderData as HeaderData, type index_Icons as Icons, index_Image as Image, type index_ImageData as ImageData, index_List as List, type index_ListData as ListData, index_Strikethrough as Strikethrough, index_Table as Table, type index_TableData as TableData, type index_TextVariant as TextVariant, index_TextVariantTune as TextVariantTune, index_ToggleBlock as ToggleBlock, type index_ToggleData as ToggleData, index_Underline as Underline, index_Undo as Undo, index_iconToHtml as iconToHtml, index_icons as icons };
+}
+
+type ToolEntry = ToolConstructable | ToolSettings;
+type BlockEditorTools = Record<string, ToolEntry | false | null>;
+type UploadResponse = {
+    success: number;
+    file: Record<string, any>;
+};
+type BlockEditorUploader = {
+    uploadByFile(file: File): Promise<UploadResponse>;
 };
+type CreateToolsOptions = {
+    uploader?: BlockEditorUploader;
+    placeholder?: string;
+    headerPlaceholder?: string;
+    tools?: BlockEditorTools;
+};
+declare function mergeTools(defaults: Record<string, ToolEntry>, overrides?: BlockEditorTools): Record<string, ToolEntry>;
+declare function createTools({ uploader, placeholder, headerPlaceholder, tools }?: CreateToolsOptions): Record<string, ToolEntry>;
+type BlockEditorHandle = {
+    editor: EditorJS | null;
+    save(): Promise<OutputData | undefined>;
+    clear(): Promise<void>;
+    render(data: OutputData): Promise<void>;
+    focus(atEnd?: boolean): Promise<void>;
+    undo(): void;
+    redo(): void;
+};
+type BlockEditorProps = Omit<EditorConfig, 'holder' | 'holderId' | 'tools' | 'data' | 'onChange' | 'onReady' | 'style'> & CreateToolsOptions & {
+    defaultValue?: OutputData;
+    undo?: boolean;
+    dragDrop?: boolean;
+    holder?: string;
+    className?: string;
+    style?: React__default.CSSProperties;
+    nonce?: string;
+    onChange?(api: API, event: BlockMutationEvent | BlockMutationEvent[]): void;
+    onInitialize?(editor: EditorJS): void;
+    onReady?(editor: EditorJS): void;
+};
+declare const BlockEditor: React__default.ForwardRefExoticComponent<Omit<EditorConfig, "data" | "style" | "onChange" | "tools" | "holder" | "holderId" | "onReady"> & CreateToolsOptions & {
+    defaultValue?: OutputData;
+    undo?: boolean;
+    dragDrop?: boolean;
+    holder?: string;
+    className?: string;
+    style?: React__default.CSSProperties;
+    nonce?: string;
+    onChange?(api: API, event: BlockMutationEvent | BlockMutationEvent[]): void;
+    onInitialize?(editor: EditorJS): void;
+    onReady?(editor: EditorJS): void;
+} & React__default.RefAttributes<BlockEditorHandle>>;
+/** @deprecated use `BlockEditor` */
+declare const RichText: React__default.ForwardRefExoticComponent<Omit<EditorConfig, "data" | "style" | "onChange" | "tools" | "holder" | "holderId" | "onReady"> & CreateToolsOptions & {
+    defaultValue?: OutputData;
+    undo?: boolean;
+    dragDrop?: boolean;
+    holder?: string;
+    className?: string;
+    style?: React__default.CSSProperties;
+    nonce?: string;
+    onChange?(api: API, event: BlockMutationEvent | BlockMutationEvent[]): void;
+    onInitialize?(editor: EditorJS): void;
+    onReady?(editor: EditorJS): void;
+} & React__default.RefAttributes<BlockEditorHandle>>;
+
+type CheckboxProps = CheckboxWithFormik | CheckboxWithoutFormik;
+interface CheckboxWithFormik extends CheckboxProps$1 {
+    name: string;
+    label?: string;
+    helperText?: string;
+    withFormik?: true;
+    FormControlLabelProps?: Partial<FormControlLabelProps>;
+}
+interface CheckboxWithoutFormik extends CheckboxProps$1 {
+    name?: never;
+    label?: string;
+    helperText?: string;
+    withFormik: false;
+    FormControlLabelProps?: Partial<FormControlLabelProps>;
+}
+declare const Checkbox: ({ withFormik, name, ...props }: CheckboxProps) => react_jsx_runtime.JSX.Element;
 
 interface DialogOptionsProps {
     label: string;
@@ -398,22 +1045,37 @@ interface DialogCustomProps extends DialogProps {
     options: DialogOptionsProps[];
     loading: boolean;
 }
-declare const Dialog: ({ open, title, loading, body, options, ...rest }: DialogCustomProps) => React__default.JSX.Element;
+declare const Dialog: ({ open, title, loading, body, options, ...rest }: DialogCustomProps) => react_jsx_runtime.JSX.Element;
 
 interface IDialogChildrenProps {
     onConfirm: (fn: (...params: any[]) => Promise<void>) => (...params: any[]) => Promise<void>;
     onCancel: () => void;
 }
+type TDialogConfirmColor = Exclude<NonNullable<ButtonProps['color']>, 'inherit'>;
+type TDialogConfirmVariant = Extract<NonNullable<ButtonProps['variant']>, 'outlined' | 'contained'>;
 interface IDialogConfirmProps {
     icon?: IconType;
     title?: string;
     body?: string;
+    /**
+     * Cor da paleta aplicada ao ícone e ao botão de confirmação.
+     * Sem valor, o ícone usa `warning` e o botão usa `primary`.
+     */
+    color?: TDialogConfirmColor;
+    /** Estilo do botão de confirmação. */
+    variant?: TDialogConfirmVariant;
     children: (props: IDialogChildrenProps) => ReactNode;
     confirmButtonText?: string;
     cancelButtonText?: string;
 }
 type TUseDialogConfirm = ReturnType<typeof UseDialogConfirm>;
-declare function UseDialogConfirm(): {
+/**
+ * Deve ser usado dentro de um `BaseDialog.Provider`.
+ * Recebe o `name` de um `BaseDialog.Create()` para controlar o diálogo,
+ * ou cria um nome próprio quando nenhum for informado.
+ */
+declare function UseDialogConfirm(dialogName?: symbol): {
+    name: symbol;
     isLoading: boolean;
     opened: boolean;
     onConfirm: (fn: (...params: any) => Promise<any>) => (...params: any[]) => Promise<void>;
@@ -422,94 +1084,193 @@ declare function UseDialogConfirm(): {
     onProceed: (event: any) => Promise<void>;
 };
 
-declare const DialogConfirm: (props: IDialogConfirmProps) => React__default.JSX.Element;
+declare const DialogConfirm: (props: IDialogConfirmProps) => react_jsx_runtime.JSX.Element;
 
-interface DialogHeaderProps extends StackProps {
-    title: string;
-    IconButtonProps?: IconButtonProps;
-    TypographyProps?: TypographyProps;
-    onClose?: () => void;
+interface EditableTableCellProps extends TableCellProps {
+    name: string;
+    TextFieldProps?: TextFieldProps;
+    type?: TextFieldProps['type'];
+    fullWidth?: boolean;
+    rowData?: Record<string, any>;
+    mask?: FactoryOpts;
+    bordered?: boolean;
+    rowIndex?: string | number;
+    formatCellValue?: (value: string) => string;
+    formatInputDefautvalue?: (value: string) => string;
+    onSave?: (props: OnSaveProps) => void;
+    onCancel?: () => void;
+}
+interface OnSaveProps {
+    name: string;
+    event: FocusEvent;
+    value: string;
+    data: Record<string, any>;
 }
+declare const EditableTableCell: (allProps: EditableTableCellProps) => react_jsx_runtime.JSX.Element;
 
-interface IBaseDialogContext {
-    opened: symbol[];
-    isOpened(dialog: symbol): boolean;
-    toggle(dialog: symbol): boolean;
-    open(dialog: symbol): void;
-    close(dialog: symbol): void;
-    closeAll(): void;
+/** @deprecated Use {@link ColumnsProps} from `BaseGrid` instead. */
+interface ColumnTitleProps {
+    name: string;
+    label: string;
+    transformer?: (value: string | number | Date) => string;
+    sx?: TableCellProps['sx'];
+}
+/** @deprecated Use {@link FilterProps} from `useFilter` instead. */
+interface FilterProps {
+    column: string;
+    value: string;
+    transformer?: (value: string | number | Date) => string;
+}
+/** @deprecated Use {@link FilterProps} from `useFilter` instead. */
+type IFilter = FilterProps;
+/** @deprecated */
+interface GridProps<T> {
+    columnTitles: ColumnTitleProps[];
+    defaultData: T[];
+    tableData: T[];
+    selectedFilters: FilterProps[];
+    setSelectedFilters(value: FilterProps[]): void;
+    setTableData(value: T[]): void;
+    updateFilters(value: Record<string, any>[]): void;
+    rowOptions?: number[];
+    footer?: ReactNode;
+    customButtons?: ReactNode;
+    isLoading?: boolean;
+    noFilterButtons?: boolean;
+    noPagination?: boolean;
+    noFilters?: boolean;
+    primaryKey?: string;
 }
+/**
+ * @deprecated Use {@link BaseGrid} with the {@link useGrid} or {@link useAsyncGrid} hook instead.
+ * `BaseGrid` separates rendering from state management, eliminating the need to pass
+ * `tableData`, `setTableData`, `selectedFilters`, and `updateFilters` as props.
+ */
+declare const Grid: <ObjectType>(props: PropsWithChildren<GridProps<ObjectType>>) => react_jsx_runtime.JSX.Element;
 
-declare function useBaseDialog(): IBaseDialogContext;
-declare function useBaseDialogInstance(): {
-    name: symbol;
-    actions: ReturnType<typeof useBaseDialog>;
-};
+/** @deprecated Use `TableCell` from `@mui/material` directly. */
+declare const Td: typeof TableCell;
 
-interface IBaseDialogInstanceProviderProps {
-    children: React__default.ReactNode;
-    name: symbol;
+/** @deprecated Use `TableRow` from `@mui/material` directly. */
+declare const Tr: _mui_material_OverridableComponent.OverridableComponent<_mui_material.TableRowTypeMap<{}, "tr">>;
+
+/** @deprecated Use the `useFilter` hook instead. */
+declare function filterData<T>(filters: FilterProps[], defaultData: {
+    current: T[];
+}): T[];
+
+interface InputProps extends StandardTextFieldProps {
+    name: string;
+    label: string;
+    shrink?: boolean;
+    withFormik?: boolean;
+}
+declare const Input: FC<InputProps>;
+
+interface InputMaskProps extends Partial<StandardTextFieldProps> {
+    name: string;
+    label: string;
+    withFormik?: boolean;
+    value?: string;
+    mask: FactoryOpts;
+    onChangeValue?: (value: string, unmaskedValue: string) => void;
+}
+declare function InputMask({ withFormik, ...rest }: InputMaskProps): react_jsx_runtime.JSX.Element;
+
+interface LargeButtonProps extends ButtonProps {
+    loading?: boolean;
+    children: ReactNode;
+    CircularProgressProps?: CircularProgressProps;
 }
+declare const LargeButton: ({ loading, children, CircularProgressProps, sx, ...rest }: LargeButtonProps) => react_jsx_runtime.JSX.Element;
 
-interface IBaseDialogContainerProps {
+type TModalProps = {
+    open: boolean;
+    onClose: () => void;
+    children: React__default.ReactNode;
     BoxProps?: BoxProps;
-    children: React__default.ReactNode | ((props: {
-        close: () => void;
-    }) => React__default.ReactNode);
+} & Omit<ModalProps, 'children'>;
+/**
+ * @deprecated Use `Dialog` or `BaseDialog` instead. `Modal` will be removed in a future release.
+ */
+declare const Modal: ({ open, onClose, BoxProps, ...rest }: TModalProps) => react_jsx_runtime.JSX.Element;
+
+type RadioOptionProps = {
+    value: string | number | boolean;
+    label: string;
+};
+type RadioOptionsProps = RadioWithFormik | RadioWithoutFormik;
+interface RadioWithFormik extends RadioGroupProps {
+    name: string;
+    label?: string;
+    options: RadioOptionProps[];
+    helperText?: string;
+    withFormik?: true;
 }
-declare const BaseDialogContainer: ({ children, BoxProps, ...rest }: IBaseDialogContainerProps) => React__default.JSX.Element;
-interface IBaseDialogBodyProps extends BoxProps {
+interface RadioWithoutFormik extends RadioGroupProps {
+    name?: never;
+    label?: string;
+    options: RadioOptionProps[];
+    helperText?: string;
+    withFormik: false;
 }
-declare const BaseDialogBody: (props: IBaseDialogBodyProps) => React__default.JSX.Element;
-interface IBaseDialogTriggerProps extends Omit<ButtonProps, 'name'> {
-    name: symbol;
+declare const Radio: ({ name, withFormik, ...rest }: RadioOptionsProps) => react_jsx_runtime.JSX.Element;
+
+interface CustomInputLabelProps extends InputLabelProps {
+    size?: 'small';
 }
-declare const BaseDialogTrigger: ({ name, onClick, ...props }: IBaseDialogTriggerProps) => React__default.JSX.Element;
-declare const BaseDialogCreate: (name?: symbol) => {
-    name: symbol;
-    Trigger: (props: Omit<IBaseDialogTriggerProps, "name">) => React__default.JSX.Element;
-    Root: (props: Omit<IBaseDialogInstanceProviderProps, "name">) => React__default.JSX.Element;
-    Container: ({ children, BoxProps, ...rest }: IBaseDialogContainerProps) => React__default.JSX.Element;
-    Header: ({ title, onClose, IconButtonProps, TypographyProps, ...props }: DialogHeaderProps) => React__default.JSX.Element;
-    Body: (props: IBaseDialogBodyProps) => React__default.JSX.Element;
-};
-declare const BaseDialog: {
-    Create: (name?: symbol) => {
-        name: symbol;
-        Trigger: (props: Omit<IBaseDialogTriggerProps, "name">) => React__default.JSX.Element;
-        Root: (props: Omit<IBaseDialogInstanceProviderProps, "name">) => React__default.JSX.Element;
-        Container: ({ children, BoxProps, ...rest }: IBaseDialogContainerProps) => React__default.JSX.Element;
-        Header: ({ title, onClose, IconButtonProps, TypographyProps, ...props }: DialogHeaderProps) => React__default.JSX.Element;
-        Body: (props: IBaseDialogBodyProps) => React__default.JSX.Element;
-    };
-    Trigger: ({ name, onClick, ...props }: IBaseDialogTriggerProps) => React__default.JSX.Element;
-    Provider: (props: any) => React__default.JSX.Element;
-    Root: (props: IBaseDialogInstanceProviderProps) => React__default.JSX.Element;
-    Container: ({ children, BoxProps, ...rest }: IBaseDialogContainerProps) => React__default.JSX.Element;
-    Header: ({ title, onClose, IconButtonProps, TypographyProps, ...props }: DialogHeaderProps) => React__default.JSX.Element;
-    Body: (props: IBaseDialogBodyProps) => React__default.JSX.Element;
+type MuiSelectPropsWithouVariant<T> = Omit<SelectProps$1<T>, 'variant'>;
+type SelectProps<T> = MuiSelectPropsWithouVariant<T> & {
+    name: string;
+    label: string;
+    withFormik?: boolean;
+    FormControlProps?: Partial<FormControlProps>;
+    InputLabelProps?: Partial<CustomInputLabelProps>;
+    helperText?: string;
 };
+declare function Select<T>({ withFormik, helperText, ...rest }: SelectProps<T>): react_jsx_runtime.JSX.Element;
 
-type FormHelperContextProps = {
-    formatErrorMessage: (message: any) => string;
-    api: AxiosInstance;
+type SwitchProps = SwitchWithFormik | SwitchWithoutFormik;
+interface SwitchWithFormik extends SwitchProps$1 {
+    name: string;
+    label?: string;
+    helperText?: string;
+    withFormik?: true;
+    FormControlLabelProps?: Partial<FormControlLabelProps>;
+}
+interface SwitchWithoutFormik extends SwitchProps$1 {
+    name?: never;
+    label?: string;
+    helperText?: string;
+    withFormik: false;
+    FormControlLabelProps?: Partial<FormControlLabelProps>;
+}
+declare const Switch: ({ withFormik, name, ...props }: SwitchProps) => react_jsx_runtime.JSX.Element;
+
+declare function getTabProps(index: string): {
+    id: string;
+    'aria-controls': string;
 };
-declare const FormHelperContext: React__default.Context<FormHelperContextProps>;
-type FormHelperProviderProps = {
-    formatErrorMessage: (message: any) => string;
-    children: ReactNode;
-    api: AxiosInstance;
+interface TabPanelProps {
+    children: React__default.ReactNode;
+    value: number;
+    index: number;
+}
+declare const TabPanel: (props: TabPanelProps) => react_jsx_runtime.JSX.Element;
+
+declare function GetInputLabel<T extends Array<Record<string, any>>, K extends T[number]['name']>(columns: T): (columnName: K) => {
+    label: any;
+    name: any;
 };
-declare const FormHelperProvider: ({ formatErrorMessage, api, children }: FormHelperProviderProps) => React__default.JSX.Element;
 
 type AlertContextProps = {
     createAlert(message: string, type: AlertColor): void;
 };
-declare const AlertContext: React__default.Context<AlertContextProps>;
+declare const AlertContext: React.Context<AlertContextProps>;
 type AlertProviderProps = {
     children: ReactNode;
 };
-declare const AlertProvider: ({ children }: AlertProviderProps) => React__default.JSX.Element;
+declare const AlertProvider: ({ children }: AlertProviderProps) => react_jsx_runtime.JSX.Element;
 
 type AuthenticateStatus = 'autenticated' | 'unauthenticated' | 'loading';
 interface AuthContextProps<T> {
@@ -518,23 +1279,35 @@ interface AuthContextProps<T> {
     signIn(credentials: Record<string, any>): Promise<boolean>;
     signOut: () => Promise<void>;
 }
-declare function createAuthContext<T>(): React__default.Context<AuthContextProps<T>>;
+declare function createAuthContext<T>(): React.Context<AuthContextProps<T>>;
 declare function CreateAuthProvider<T>({ api, children, sessionTokenName, Provider }: {
     Provider: Provider<AuthContextProps<T>>;
     children: ReactNode;
     api: AxiosInstance;
     sessionTokenName: string;
-}): React__default.JSX.Element;
+}): react_jsx_runtime.JSX.Element;
 
-declare class HttpError extends Error {
-    status: number;
-    constructor(status: number, message: any);
-}
+type FormHelperContextProps = {
+    formatErrorMessage: (message: any) => string;
+    api: AxiosInstance;
+};
+declare const FormHelperContext: React.Context<FormHelperContextProps>;
+type FormHelperProviderProps = {
+    formatErrorMessage: (message: any) => string;
+    children: ReactNode;
+    api: AxiosInstance;
+};
+declare const FormHelperProvider: ({ formatErrorMessage, api, children }: FormHelperProviderProps) => react_jsx_runtime.JSX.Element;
 
 declare class DomainError extends Error {
     constructor(message: any);
 }
 
+declare class HttpError extends Error {
+    status: number;
+    constructor(status: number, message: any);
+}
+
 interface BaseRequest {
     method?: string;
 }
@@ -694,6 +1467,10 @@ declare class AuthHelper {
     invalidateCookies: (res: HelperResponse) => any;
 }
 
+declare const useAlert: () => {
+    createAlert(message: string, type: _mui_material.AlertColor): void;
+};
+
 type SortedDirectionProps = 'asc' | 'desc';
 interface SortedByProps {
     prop: string;
@@ -706,7 +1483,7 @@ interface SearchOptions {
 }
 interface UseGridBaseProps<T> {
     columns: ColumnsProps[];
-    filters?: FilterProps[];
+    filters?: FilterProps$1[];
     rowsPerPageOptions?: number[];
     search?: SearchOptions;
     defaultCurrentPage?: number;
@@ -716,7 +1493,7 @@ interface UseGridBaseProps<T> {
 }
 type UseGridPropsOnRequest<T> = {
     onRequest(props: {
-        filters: FilterProps[];
+        filters: FilterProps$1[];
         page: number;
         rowsPerPage: number;
         search?: SearchOptions;
@@ -751,15 +1528,6 @@ declare function useAsyncGrid<T extends Record<string, any>>({ columns, filters,
 
 declare function useEvent(event: keyof WindowEventMap, handler: (ev: any) => void, passive?: boolean): void;
 
-declare function useLoading<T = string>(): {
-    isLoading: (prop: T) => boolean;
-    setLoading: (prop: T, remove?: boolean) => void;
-};
-
-declare const useAlert: () => {
-    createAlert(message: string, type: _mui_material.AlertColor): void;
-};
-
 type Methods = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options';
 type HandleProps = {
     name: `${Methods}:${string}`;
@@ -772,4 +1540,9 @@ declare function useFormHelper(): {
     createAlert(message: string, type: _mui_material.AlertColor): void;
 };
 
-export { AlertContext, AlertProvider, ApiHelper, type AuthContextProps, AuthHelper, Autocomplete, BaseDialog, BaseDialogBody, BaseDialogContainer, BaseDialogCreate, BaseDialogTrigger, BaseGrid, BaseGridAutoRows, type BaseRequest, type BaseResponse, Checkbox, type ColumnTitleProps, type ColumnsProps, CreateAuthProvider, Dialog, DialogConfirm, DomainError, EditableTableCell, type FilterCompareType, type FilterProps, FormHelperContext, FormHelperProvider, GetInputLabel, Grid, type HandlerProps, type HelperRequest, type HelperResponse, HttpError, type IBaseDialogBodyProps, type IBaseDialogContainerProps, type IBaseDialogTriggerProps, type IDialogConfirmProps, type IFilter, Input, InputMask, LargeButton, type MethodProps, type MiddlewaresProps, Modal, type NextHandlerApiRequest, type NookiesRequest, type NookiesResponse, Radio, Select, type ServerSidePropsContext, type SortedByProps$1 as SortedByProps, Switch, type TApiHelperProps, type TApiOptions, type TUseDialogConfirm, TabPanel, type TabPanelProps, Td, Tr, UseDialogConfirm, createApiHelper, createAuthContext, createFilter, destroyCookie, filterData, getTabProps, nookies, parseCookies, setCookie, useAlert, useAsyncGrid, useBaseDialog, useBaseDialogInstance, useEvent, useFilter, useFormHelper, useGrid, useLoading };
+declare function useLoading<T = string>(): {
+    isLoading: (prop: T) => boolean;
+    setLoading: (prop: T, remove?: boolean) => void;
+};
+
+export { AlertContext, AlertProvider, ApiHelper, type AuthContextProps, AuthHelper, Autocomplete, BaseDialog, BaseDialogBody, BaseDialogContainer, BaseDialogCreate, BaseDialogTrigger, BaseGrid, BaseGridAutoRows, type BaseRequest, type BaseResponse, BlockEditor, type BlockEditorHandle, type BlockEditorProps, type BlockEditorTools, type BlockEditorUploader, Checkbox, type ColumnTitleProps, type ColumnsProps, CreateAuthProvider, type CreateToolsOptions, Dialog, DialogConfirm, DomainError, EditableTableCell, type FilterCompareType, type FilterProps$1 as FilterProps, FormHelperContext, FormHelperProvider, GetInputLabel, Grid, type HandlerProps, type HelperRequest, type HelperResponse, HttpError, type IBaseDialogBodyProps, type IBaseDialogContainerProps, type IBaseDialogTriggerProps, type IDialogConfirmProps, type IFilter, Input, InputMask, LargeButton, type MethodProps, type MiddlewaresProps, Modal, type NextHandlerApiRequest, type NookiesRequest, type NookiesResponse, Radio, RichText, Select, type ServerSidePropsContext, type SortedByProps$1 as SortedByProps, Switch, type TApiHelperProps, type TApiOptions, type TDialogConfirmColor, type TDialogConfirmVariant, type TUseDialogConfirm, TabPanel, type TabPanelProps, Td, type ToolEntry, Tr, type UploadResponse, UseDialogConfirm, icons as blockEditorIcons, index as blockEditorPlugins, createApiHelper, createAuthContext, createFilter, createTools, destroyCookie, filterData, getTabProps, iconToHtml, mergeTools, nookies, parseCookies, setCookie, useAlert, useAsyncGrid, useBaseDialog, useBaseDialogInstance, useEvent, useFilter, useFormHelper, useGrid, useLoading };