@free-dom/react-components 2.0.0

package/dist/types/index.d.ts

@@ -0,0 +1,2806 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { ForwardRefExoticComponent, PropsWithoutRef, DetailedHTMLProps, ButtonHTMLAttributes, FunctionComponent, SVGProps, PropsWithChildren, ReactNode, CSSProperties } from 'react';
+import { IconName, IconProps } from '@freedom/react-icons';
+import { ReactDatePickerProps } from 'react-datepicker';
+import * as Menu from '@radix-ui/react-dropdown-menu';
+import { SelectInstance } from 'react-select';
+import * as RadixToolTip from '@radix-ui/react-tooltip';
+import { EditorOptions } from '@tiptap/react';
+
+type Combine<First, Second> = Omit<First, keyof Second> & Second;
+
+type BackToTopOwnProps = {
+    /**
+     * Especifica qual container deve ser a referência para
+     * o componente.
+     */
+    target?: 'window' | 'container';
+    /**
+     * Especifica se o botão deve estar sempre visível ou não.
+     * Por padrão ele fica visível apenas quando detecta
+     * scroll no container de referência.
+     */
+    alwaysVisible?: boolean;
+};
+type ReactButtonProps = Omit<React__default.DetailedHTMLProps<React__default.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, 'color'>;
+type BackToTopProps = Combine<ReactButtonProps, BackToTopOwnProps>;
+declare function BackToTop({ className, target, alwaysVisible, ...rest }: BackToTopProps): react_jsx_runtime.JSX.Element;
+
+type Variant$5 = 'primary' | 'secondary' | 'text' | 'danger';
+type ButtonOwnProps = {
+    /**
+     * Especifica o tipo de Button que será renderizado.
+     */
+    variant?: Variant$5;
+    /**
+     * Especifica se o Button deve ser compacto ou não.
+     * O modo compacto é um botão com padding reduzido.
+     */
+    compact?: boolean;
+    /**
+     * Especifica se o botão está em estado de loading ou não.
+     */
+    loading?: boolean;
+    /**
+     * Especifica um tipo de ícone pré-definido que deve ser
+     * renderizado dentro do Button.
+     */
+    icon?: IconName;
+    /**
+     * Especifica a posição dos ícones que fazem parte do botão.
+     * A posição afeta o ícone de loading e o ícone dentro do botão,
+     * caso seja passado a prop `icon` ou `renderIcon`.
+     */
+    iconPosition?: 'left' | 'right';
+    /**
+     * Prop que permite que o usuário possa renderizar um ícone customizado
+     * que não está previsto nos ícones pré-definidos da props `icon`.
+     */
+    renderIcon?: React__default.FunctionComponent<React__default.SVGProps<SVGSVGElement>>;
+};
+type ButtonProps = Combine<React__default.DetailedHTMLProps<React__default.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, ButtonOwnProps>;
+declare const Button: React__default.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;
+
+type CheckboxProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    /**
+     * Id único que identifica o checkbox.
+     */
+    id?: string;
+    /**
+     * Label que será renderizada do lado direito do checkbox.
+     */
+    label?: string;
+    /**
+     * Especifica se o checkbox deve ser renderizado como checked por padrão.
+     */
+    defaultChecked?: boolean;
+    /**
+     * Propriedade que controla o estado do checkbox de checked ou não.
+     */
+    checked?: boolean | 'indeterminate';
+    /**
+     * Especifica se o checkbox deve estar desabilitado.
+     */
+    disabled?: boolean;
+    /**
+     * Evento disparado quando o checkbox é clicado.
+     */
+    onCheckedChange?: (checked: boolean) => void;
+    /**
+     * Evento opcional que pode ser passado e disparado quando clicado no checkbox
+     */
+    onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+    /**
+     * Especifica se o checkbox deve ser obrigatorio.
+     */
+    required?: boolean;
+    /**
+     * Especifica o nome do checkbox.
+     */
+    name?: string;
+    /**
+     * Especifica o valor que o checkbox deve ter.
+     */
+    value?: string;
+};
+declare function Checkbox({ className, defaultChecked, onCheckedChange, onClick, checked, label, disabled, ...rest }: React.PropsWithChildren<CheckboxProps>): react_jsx_runtime.JSX.Element;
+
+type ChipProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    /**
+     * Função disparada ao clicar no Chip. Faz com que o Chip
+     * seja renderizado de maneira interativa.
+     */
+    onClick?: (event: React.MouseEvent<HTMLButtonElement | HTMLDivElement>, args: ChipMouseEventArgs) => void;
+    /**
+     * Determina se é Chip deve ser do tipo filtro.
+     */
+    filter?: boolean;
+    /**
+     * Id único que identifica o Chip.
+     */
+    id?: string;
+    /**
+     * Função disparada ao clicar no botão de fechar de um Chip
+     * do tipo filter (props filter=true).
+     */
+    onClose?: (event: React.MouseEvent<HTMLButtonElement>, args: ChipMouseEventArgs) => void;
+    /**
+     * Especifica se o chip deve ficar no modo ativo, isso é, com borda.
+     */
+    active?: boolean;
+    /**
+     * Especifica um tipo de ícone pré-definido que deve ser
+     * renderizado dentro do Chip.
+     */
+    icon?: IconName;
+    /**
+     * Prop que permite que o usuário possa renderizar um ícone customizado
+     * que não está previsto nos ícones pré-definidos da props `icon`.
+     */
+    renderIcon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;
+    /**
+     * Especifica se o Chip deve estar desabilitado.
+     */
+    disabled?: boolean;
+};
+type ChipMouseEventArgs = {
+    id?: string;
+    active: boolean;
+};
+declare function Chip({ id, children, className, onClick, active, filter, onClose, renderIcon, icon, disabled, }: React.PropsWithChildren<ChipProps>): react_jsx_runtime.JSX.Element;
+
+type DatePickerCustomInputOwnProps = {
+    /**
+    * Label que será renderizada acima do input. Por motivos
+    * de acessibilidade deve
+    ser utilizado em conjunto com a prop `id` ou `name`.
+    */
+    label?: string;
+    /**
+     * Especifica se o componente deve ser compacto ou não.
+     * O modo compacto é um componente de input com padding reduzido.
+     */
+    compact?: boolean;
+    /**
+     * Renderiza um input com aparência de erro e mensagem logo abaixo do input.
+     * Se utilizada com a prop `hint`, a prop `error` terá prioridade e
+     * irá sobrescrever a mensagem de `hint`.
+     */
+    error?: string;
+    /**
+     * Renderiza uma mensagem de informação logo abaixo do input.
+     * Se utilizada com a prop `error`, a prop `error` terá prioridade e
+     * irá sobrescrever a mensagem de `hint`.
+     */
+    hint?: string;
+    minDate?: Date;
+    maxDate?: Date;
+    onClick?: React__default.MouseEventHandler<HTMLButtonElement | HTMLInputElement>;
+    value?: string;
+    isRange?: boolean;
+    onlyMonthYearPicker?: boolean;
+};
+type DatePickerCustomInputProps = React__default.InputHTMLAttributes<HTMLInputElement> & DatePickerCustomInputOwnProps;
+
+type DatePickerConditionalProps = {
+    /**
+     *  Habilita a seleção de um período entre duas datas.
+     */
+    selectsRange?: never;
+    /**
+     * Evento disparado ao preencher um input com uma data válida.
+     */
+    onChange?: (date: Date, event?: React__default.SyntheticEvent<any, Event>) => void;
+    /**
+     * Especifica o valor da data inicial do período. Utilizado quando é necessário
+     * ter um componente controlado.
+     */
+    startDate?: never;
+    /**
+     * Especifica o valor da data inicial do período. Utilizado quando é necessário
+     * ter um componente controlado.
+     */
+    endDate?: never;
+    /**
+     * Prop passada para controlar o valor inicial da data inicial do período.
+     */
+    defaultEndDate?: never;
+    /**
+     * Prop passada para controlar o valor inicial da data final do período.
+     */
+    defaultStartDate?: never;
+    /**
+     * Determina o tamanho máximo do intervalo entre as duas datas do período.
+     */
+    maxRangeInterval?: never;
+    /**
+     * Habilita a seleção apenas de mês e ano
+     */
+    onlyMonthYearPicker?: boolean;
+} | {
+    selectsRange: true;
+    onChange?: (date: [Date | null, Date | null], event?: React__default.SyntheticEvent<any, Event>) => void;
+    startDate?: Date | null;
+    endDate?: Date | null;
+    defaultStartDate?: Date | null;
+    defaultEndDate?: Date | null;
+    maxRangeInterval?: number;
+    onlyMonthYearPicker?: never;
+};
+type DatePickerOwnProps = DatePickerConditionalProps & {
+    /**
+     * Data mínima que pode ser selecionada.
+     */
+    minDate?: Date;
+    /**
+     * Data máxima que pode ser selecionada.
+     */
+    maxDate?: Date;
+    /**
+     * Prop passada para controlar o valor inicial.
+     */
+    defaultSelected?: Date | null;
+    /**
+     * Prop passada para controlar o valor do Date Picker.
+     */
+    selected?: Date | null;
+    /**
+     * Especifica valor do input do DatePicker. Utilizado quando é necessário
+     * ter um componente controlado.
+     */
+    value?: string;
+    /**
+     * Determina a direção que o DatePicker deve ser renderizado.
+     */
+    popperPlacement?: ReactDatePickerProps['popperPlacement'];
+};
+type DatePickerProps = Combine<Omit<DatePickerCustomInputProps, 'isRange'>, DatePickerOwnProps>;
+declare const DatePicker: React__default.ForwardRefExoticComponent<DatePickerProps & React__default.RefAttributes<HTMLInputElement>>;
+
+type DropdownMenuSubContentProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    /**
+     * Função chamada quando um evento do mouse ocorre fora do componente.
+     * Isso pode ser evitado chamando `event.preventDefault`
+     */
+    onPointerDownOutside?: Menu.DropdownMenuContentProps['onPointerDownOutside'];
+};
+
+type DropdownMenuContentProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    /**
+     * Função chamada quando um evento do mouse ocorre fora do componente.
+     * Isso pode ser evitado chamando `event.preventDefault`
+     */
+    onPointerDownOutside?: Menu.DropdownMenuContentProps['onPointerDownOutside'];
+};
+
+type DropdownMenuGroupProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    /**
+     * Texto que será exibido como nome do grupo.
+     */
+    label: string;
+};
+declare function DropdownMenuGroup({ children, label, ...rest }: React.PropsWithChildren<DropdownMenuGroupProps>): react_jsx_runtime.JSX.Element;
+
+type DropdownMenuIconProps = {
+    /**
+     * Nome do ícone que será exibido.
+     */
+    icon?: IconName;
+    /**
+     * Ícone customizado especificado pelo usuário.
+     */
+    renderIcon?: React__default.FunctionComponent<React__default.SVGProps<SVGSVGElement>>;
+};
+declare function DropdownMenuIcon({ icon, renderIcon }: DropdownMenuIconProps): react_jsx_runtime.JSX.Element;
+
+type DropdownMenuItemProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    /**
+     * Quando `true`, impede que o usuário interaja com o item.
+     */
+    disabled?: boolean;
+    /**
+     * Função chamada quando o item é selecionado.
+     * Chamar `event.preventDefault` impede o fechamento do menu ao selecionar o item.
+     */
+    onSelect?: (event: Event) => void;
+    /**
+     * Altera o componente para o filho único (pode ser uma tag HTML ou
+     * um elemento customizado). Isso irá mesclar as props do componenente
+     * original com as props do elemento/componente fornecido
+     */
+    asChild?: boolean;
+    /**
+     * Altera a propagação do evento de click ao componente pai
+     */
+    stopPropagation?: boolean;
+};
+declare function DropdownMenuItem({ className, children, stopPropagation, ...rest }: React.PropsWithChildren<DropdownMenuItemProps>): react_jsx_runtime.JSX.Element;
+
+type DropdownMenuSeparatorProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+};
+declare function DropdownMenuSeparator({ className, ...rest }: DropdownMenuSeparatorProps): react_jsx_runtime.JSX.Element;
+
+type DropdownMenuTextOwnProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+};
+type DropdownMenuTextProps = Combine<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, DropdownMenuTextOwnProps>;
+declare function DropdownMenuText({ className, children, ...rest }: DropdownMenuTextProps): react_jsx_runtime.JSX.Element;
+
+type DropdownMenuSubProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    /**
+     * Quando `true`, impede que o usuário interaja com o item.
+     */
+    disabled?: boolean;
+    /**
+     * Altera o componente para o filho único (pode ser uma tag HTML ou
+     * um elemento customizado). Isso irá mesclar as props do componente
+     * original com as props do elemento/componente fornecido
+     */
+    asChild?: boolean;
+    /**
+     * Define o estado inicial como aberto
+     */
+    defaultOpen?: boolean;
+    /**
+     * Controla o estado de abertura do subItem
+     */
+    open?: boolean;
+    /**
+     * Callback disparado quando o estado de abertura do subitem muda
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Texto do trigger
+     */
+    label: string;
+};
+declare function DropdownMenuSub({ className, children, asChild, disabled, label, ...rest }: React.PropsWithChildren<DropdownMenuSubProps>): react_jsx_runtime.JSX.Element;
+
+type DropdownMenuRootProps = {
+    /**
+     * Define o estado `open` do menu ao ser renderizado.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Determina se o menu está aberto ou fechado.  Deve ser usado em conjunto com `onOpenChange`
+     */
+    open?: boolean;
+    /**
+     * Evento disparado quando o estado `open` do menu é alterado.
+     */
+    onOpenChange?: Menu.DropdownMenuProps['onOpenChange'];
+    /**
+     * Define um ícone customizado para o botão do menu.
+     * @default 'moreVert'
+     */
+    icon?: IconName;
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    /**
+     * Título que aparece em formato de tooltip para descrever componente.
+     */
+    title?: string;
+    /**
+     * Define o container pai onde o menu será renderizado
+     * @default document.body
+     */
+    containerRef?: React.RefObject<HTMLElement>;
+    /**
+     * Altera a propagação do evento de click ao componente pai
+     */
+    stopPropagation?: boolean;
+};
+declare function DropdownMenu({ children, icon, className, title, containerRef, stopPropagation, ...rest }: React.PropsWithChildren<DropdownMenuRootProps>): react_jsx_runtime.JSX.Element;
+declare namespace DropdownMenu {
+    var Content: React$1.ForwardRefExoticComponent<DropdownMenuContentProps & {
+        children?: React$1.ReactNode | undefined;
+    } & React$1.RefAttributes<HTMLDivElement>>;
+    var Group: typeof DropdownMenuGroup;
+    var Icon: typeof DropdownMenuIcon;
+    var Item: typeof DropdownMenuItem;
+    var Separator: typeof DropdownMenuSeparator;
+    var Text: typeof DropdownMenuText;
+    var Sub: typeof DropdownMenuSub;
+    var SubContent: React$1.ForwardRefExoticComponent<DropdownMenuSubContentProps & {
+        children?: React$1.ReactNode | undefined;
+    } & React$1.RefAttributes<HTMLDivElement>>;
+}
+
+type IconButtonOwnProps = {
+    /**
+     * Especifica se o botão está em estado de loading ou não.
+     */
+    loading?: boolean;
+    /**
+     * Especifica um tipo de ícone pré-definido que deve ser
+     * renderizado dentro do Button.
+     */
+    icon?: IconName;
+    /**
+     * Prop que permite que o usuário possa renderizar um ícone customizado
+     * que não está previsto nos ícones pré-definidos da props `icon`.
+     */
+    renderIcon?: FunctionComponent<SVGProps<SVGSVGElement>>;
+} & Pick<IconProps, 'color'>;
+type IconButtonProps = Combine<DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, IconButtonOwnProps>;
+declare const IconButton: ForwardRefExoticComponent<PropsWithoutRef<IconButtonProps>>;
+
+type Mask = 'cep' | 'phoneNumber' | 'cpf' | 'cnpj' | 'currency' | 'cpfOrCnpj' | 'number' | 'hour';
+
+type TextInputOwnProps = {
+    /**
+    * Label que será renderizada acima do input. Por motivos
+    * de acessibilidade deve
+    ser utilizado em conjunto com a prop `id` ou `name`.
+    */
+    label?: string;
+    /**
+     * Especifica se o componente deve ser compacto ou não.
+     * O modo compacto é um componente de input com padding reduzido.
+     */
+    compact?: boolean;
+    /**
+     * Renderiza um input com aparência de erro e mensagem logo abaixo do input.
+     * Se utilizada com a prop `hint`, a prop `error` terá prioridade e
+     * irá sobrescrever a mensagem de `hint`.
+     */
+    error?: string;
+    /**
+     * Renderiza uma mensagem de informação logo abaixo do input.
+     * Se utilizada com a prop `error`, a prop `error` terá prioridade e
+     * irá sobrescrever a mensagem de `hint`.
+     */
+    hint?: string;
+    /**
+     * Renderiza um texto dentro do container, à esquerda do input. Não
+     * deve ser utilizado em conjunto com a prop `icon` ou `renderIcon`.
+     */
+    prefix?: string;
+    /**
+     * Renderiza um texto dentro do container, à direita do input. Não
+     * deve ser utilizado em conjunto com a prop `onClear`.
+     */
+    sufix?: string | JSX.Element;
+    /**
+     * Mascarás pre-definidas que formatam o texto digitado pelo usuário
+     * automaticamente.
+     */
+    mask?: Mask | ((value: string) => string);
+    /**
+     * Especifica um tipo de ícone pré-definido que deve ser
+     * renderizado dentro do container, à esquerda do input.
+     */
+    icon?: IconName;
+    /**
+     * Prop que permite que o usuário possa renderizar um ícone customizado
+     * que não está previsto nos ícones pré-definidos da props `icon`.
+     */
+    renderIcon?: React__default.FunctionComponent<React__default.SVGProps<SVGSVGElement>>;
+    /**
+     * Define o estado de loading do input
+     */
+    loading?: boolean;
+};
+type TextInputProps = React__default.InputHTMLAttributes<HTMLInputElement> & TextInputOwnProps;
+declare const TextInput: React__default.ForwardRefExoticComponent<React__default.InputHTMLAttributes<HTMLInputElement> & TextInputOwnProps & React__default.RefAttributes<HTMLInputElement>>;
+
+type MultilineTextInputPropsOwnProps = {
+    /**
+    * Label que será renderizada acima do input. Por motivos
+    * de acessibilidade deve
+    ser utilizado em conjunto com a prop `id` ou `name`.
+    */
+    label?: string;
+    /**
+     * Renderiza um input com aparência de erro e mensagem logo abaixo do input.
+     * Se utilizada com a prop `hint`, a prop `error` terá prioridade e
+     * irá sobrescrever a mensagem de `hint`.
+     */
+    error?: string;
+    /**
+     * Renderiza uma mensagem de informação logo abaixo do input.
+     * Se utilizada com a prop `error`, a prop `error` terá prioridade e
+     * irá sobrescrever a mensagem de `hint`.
+     */
+    hint?: string;
+    /**
+     * Usado em conjunto com a prop `isMultiline` para especificar o número
+     * máximo de linhas visíveis (antes de aparecer o scroll).
+     */
+    maxRows?: number;
+};
+type MultilineTextInputProps = Combine<React__default.DetailedHTMLProps<React__default.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, MultilineTextInputPropsOwnProps>;
+declare function HTMLTextAreaElement({ label, className, hint, onChange, defaultValue, style, name, value: valueProps, id, error, maxRows, maxLength, ...rest }: MultilineTextInputProps, forwardedRef: React__default.ForwardedRef<HTMLTextAreaElement>): react_jsx_runtime.JSX.Element;
+declare const MultilineTextInput: React__default.ForwardRefExoticComponent<Omit<MultilineTextInputProps, "ref"> & React__default.RefAttributes<HTMLTextAreaElement>>;
+
+type PasswordInputOwnProps = {
+    /**
+    * Label que será renderizada acima do input. Por motivos
+    * de acessibilidade deve
+    ser utilizado em conjunto com a prop `id` ou `name`.
+    */
+    label?: string;
+    /**
+     * Renderiza um input com aparência de erro e mensagem logo abaixo do input.
+     * Se utilizada com a prop `hint`, a prop `error` terá prioridade e
+     * irá sobrescrever a mensagem de `hint`.
+     */
+    error?: string;
+    /**
+     * Renderiza uma mensagem de informação logo abaixo do input.
+     * Se utilizada com a prop `error`, a prop `error` terá prioridade e
+     * irá sobrescrever a mensagem de `hint`.
+     */
+    hint?: string;
+};
+type PasswordInputProps = Combine<React__default.DetailedHTMLProps<React__default.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, PasswordInputOwnProps>;
+declare const PasswordInput: React__default.ForwardRefExoticComponent<Omit<PasswordInputProps, "ref"> & React__default.RefAttributes<HTMLInputElement>>;
+
+type ModalTriggerProps = {
+    /** Elemento responsável por abrir o Modal. */
+    children: React__default.ReactNode;
+};
+declare function ModalTrigger({ children, ...rest }: ModalTriggerProps): react_jsx_runtime.JSX.Element;
+
+type ConditionalProps = {
+    /**
+     * Prop responsável por renderizar um botão de cancelar, que fecha o modal sem executar uma ação.
+     * O botão só será renderizado caso seja utilizado junto da prop `action`.
+     */
+    withCancelAction?: boolean;
+    /**
+     * Prop responsável por realizar uma ação antes do fechamento do modal após clicar no botão "Cancelar".
+     * A ação pode ser tanto síncrona quanto assíncrona.
+     */
+    onClose?: (event: unknown) => void | Promise<void>;
+    /**
+     * Prop responsável por renderizar um botão de ação, que executa uma ação e fecha o modal em seguida.
+     * A ação pode ser tanto síncrona quanto assíncrona.
+     */
+    action: ModalAction;
+    /**
+     * Altera a label do botão "Cancelar"
+     * @default Cancelar
+     */
+    cancelLabel?: string;
+} | {
+    onClose?: never;
+    action?: never;
+    withCancelAction?: never;
+    cancelLabel?: never;
+};
+type ModalAction = {
+    label: string;
+    variant?: ButtonProps['variant'];
+    onClick?: (event: unknown) => void | Promise<void>;
+    disabled?: ButtonProps['disabled'];
+    loading?: ButtonProps['loading'];
+};
+type ModalActionsProps = ConditionalProps;
+
+type ModalBodyProps = {
+    /**
+     * Texto descritivo que aparece no corpo do Modal.
+     * */
+    description?: string;
+    /**
+     * Elemento responsável pelo conteúdo que aparece no corpo do Modal.
+     * */
+    children: React.ReactNode;
+    className?: string;
+};
+
+type ModalHeaderProps = {
+    /**
+     * Título para ser exibido no topo do Modal.
+     */
+    title: string;
+    /**
+     * Prop para controlar se o modal pode ser arrastado
+     * @default true
+     */
+    isDraggable?: boolean;
+};
+
+type ModalContentProps = ModalHeaderProps & ModalBodyProps & ModalActionsProps;
+
+type ModalContentWrapperProps = ModalContentProps;
+declare function ModalContentWrapper({ children, isDraggable, ...contentProps }: ModalContentWrapperProps): react_jsx_runtime.JSX.Element;
+
+type ModalProps = {
+    /**
+     * Prop que controla a visibilidade do modal.
+     */
+    open?: boolean;
+    /**
+     * Evento disparado ao alterar a visibilidade do modal
+     */
+    onOpenChange?: (open: boolean) => void;
+};
+declare function Modal({ children, open: openProps, onOpenChange, }: React.PropsWithChildren<ModalProps>): react_jsx_runtime.JSX.Element;
+declare namespace Modal {
+    var Trigger: typeof ModalTrigger;
+    var ContentWrapper: typeof ModalContentWrapper;
+}
+
+type SelectOption = {
+    value: unknown;
+    label: string;
+    disabled?: boolean;
+    separator?: boolean;
+    icon?: IconName;
+    iconPosition?: 'left' | 'right';
+};
+type SelectGroupOption = {
+    label: string;
+    options: SelectOption[];
+};
+type SelectIsMultiConditionalProps = {
+    /**
+     * Especifica se o componente deve suportar seleção de múltiplas opções ou não
+     */
+    multi: true;
+    /**
+     * Evento disparado ao selecionar uma opção. Utilizado quando é necessário
+     * ter um componente controlado.
+     */
+    onChange?: (option: readonly SelectOption[] | null) => void;
+    /**
+     * Especifica valor selecionado. Utilizado quando é necessário
+     * ter um componente controlado.
+     */
+    value?: readonly SelectOption[] | null;
+    /**
+     * Especifica valor padrão que será utilizado na renderização inicial
+     */
+    defaultValue?: readonly SelectOption[] | null;
+    /**
+     * Especifica se o componente terá a opção de filtro dentre as opções, default `false`
+     */
+    searchable?: never;
+} | {
+    multi: false;
+    onChange?: (option: SelectOption | null) => void;
+    value?: SelectOption | null;
+    defaultValue?: SelectOption | null;
+    searchable?: boolean;
+} | {
+    multi?: never;
+    onChange?: (option: SelectOption | null) => void;
+    value?: SelectOption | null;
+    defaultValue?: SelectOption | null;
+    searchable?: boolean;
+};
+type SelectProps = Pick<React__default.SelectHTMLAttributes<HTMLInputElement>, 'onBlur' | 'onFocus'> & SelectIsMultiConditionalProps & {
+    /**
+     * Id que será atribuído ao componente
+     */
+    id?: string;
+    /**
+     * Nome que será atribuído ao componente
+     */
+    name?: string;
+    /**
+    * Label que será renderizada acima do input. Por motivos
+    * de acessibilidade deve
+    ser utilizado em conjunto com a prop `id` ou `name`.
+    */
+    label?: string;
+    /**
+     * Especifica se um componente deve estar desabilitado ou não
+     */
+    disabled?: boolean;
+    /**
+     * Renderiza um input com aparência de erro e mensagem logo abaixo do input.
+     * Se utilizada com a prop `hint`, a prop `error` terá prioridade e
+     * irá sobrescrever a mensagem de `hint`.
+     */
+    error?: string;
+    /**
+     * Renderiza uma mensagem de informação logo abaixo do input.
+     * Se utilizada com a prop `error`, a prop `error` terá prioridade e
+     * irá sobrescrever a mensagem de `hint`.
+     */
+    hint?: string;
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    /**
+     * Especifica se o menu deve estar aberto por padrão
+     */
+    defaultMenuOpen?: boolean;
+    /**
+     * Objeto de estilo que pode ser utilizado para estilizar o componente
+     */
+    style?: React__default.CSSProperties;
+    /**
+     * Especifica um tipo de ícone pré-definido que deve ser
+     * renderizado dentro do container, à esquerda do input.
+     */
+    icon?: IconName;
+    /**
+     * Prop que permite que o usuário possa renderizar um ícone customizado
+     * que não está previsto nos ícones pré-definidos da props `icon`.
+     */
+    renderIcon?: React__default.FunctionComponent<React__default.SVGProps<SVGSVGElement>>;
+    /**
+     * Especifica se o componente deve ser compacto ou não.
+     * O modo compacto é um componente de input com padding reduzido.
+     */
+    compact?: boolean;
+    /**
+     * Opções que serão disponibilizadas como escolhas para o componente.
+     */
+    options?: SelectOption[] | SelectGroupOption[];
+    /**
+     * Especifica o texto que será renderizado quando não houver opção selecionada.
+     */
+    placeholder?: string;
+    /**
+     * Especifica se o menu do componente deve ser fechado após selecionar uma opção
+     */
+    closeMenuOnSelect?: boolean;
+    /**
+     * Define o container pai onde o menu será renderizado
+     * @default document.body
+     */
+    containerRef?: React__default.RefObject<HTMLElement>;
+    /**
+     * Define a posição de abertura do menu
+     * @default auto
+     */
+    menuPlacement?: 'auto' | 'bottom' | 'top';
+    /**
+     * Define o 'position' do menu
+     * @default absolute
+     */
+    menuPosition?: 'fixed' | 'absolute';
+    /**
+     * Define se o menu do select deve calcular automaticamente sua posição
+     * @default true
+     */
+    menuAutoCalculatePosition?: boolean;
+    /**
+     * Especifica um valor para aplicar no tabIndex do Select
+     */
+    tabIndex?: number;
+    /**
+     * Define o comportamento do cálculo de tamanho do menu do select
+     * @default 'input'
+     */
+    menuWidthMode?: 'input' | 'content';
+};
+declare const Select: React__default.ForwardRefExoticComponent<SelectProps & React__default.RefAttributes<SelectInstance<SelectOption, boolean, SelectGroupOption>>>;
+
+type Variant$4 = 'warning' | 'info' | 'success' | 'danger' | 'severe-warning' | 'custom';
+type TagOwnProps = {
+    /**
+     * Especifica o tipo de Tag que será renderizado.
+     */
+    variant: Variant$4;
+    /**
+     * Classes de estilo passadas para o elemento mais externo do componente.
+     */
+    className?: string;
+};
+type TagProps = Combine<React.HTMLAttributes<HTMLElement>, TagOwnProps>;
+declare function Tag({ variant, children, className, ...rest }: TagProps): react_jsx_runtime.JSX.Element;
+
+type Variant$3 = 'heading' | 'headingMedium' | 'headingSmall' | 'subheading' | 'subheadingSmall' | 'body' | 'bodySmall' | 'label' | 'caption';
+type TypographyProps = {
+    /**
+     * Especifica o tipo de texto que será renderizado.
+     */
+    as: Variant$3;
+    /**
+     * Componente que será renderizado
+     */
+    children: React__default.ReactNode;
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    /**
+     * estlos inline customizados que serao aplicado ao componente.
+     */
+    style?: React__default.CSSProperties;
+};
+declare const Typography: React__default.ForwardRefExoticComponent<TypographyProps & React__default.RefAttributes<HTMLElement>>;
+
+type SwitchProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    /**
+     * Id único que identifica o switch.
+     */
+    id?: string;
+    /**
+     * Label que será renderizada do lado direito do switch.
+     */
+    label?: string;
+    /**
+     * Especifica se o switch deve ser renderizado como checked por padrão.
+     */
+    defaultChecked?: boolean;
+    /**
+     * Propriedade que controla o estado do switch de checked ou não.
+     */
+    checked?: boolean | undefined;
+    /**
+     * Especifica se o switch deve estar desabilitado.
+     */
+    disabled?: boolean;
+    /**
+     * Evento disparado quando o switch é clicado.
+     */
+    onCheckedChange?: (checked: boolean) => void;
+    /**
+     * Especifica se o switch deve ser obrigatorio.
+     */
+    required?: boolean;
+    /**
+     * Especifica o nome do switch.
+     */
+    name?: string;
+    /**
+     * Especifica o valor que o switch deve ter.
+     */
+    value?: string;
+    /**
+     * Especifica se o switch deve ser renderizado com ícones de checked e unchecked.
+     */
+    withIcon?: boolean;
+    /**
+     * Especifica o ícone que deve ser renderizado quando o switch estiver checked.
+     * @default 'check'
+     */
+    checkedIcon?: IconName;
+    /**
+     * Especifica o ícone que deve ser renderizado quando o switch estiver unchecked.
+     * @default 'close'
+     */
+    uncheckedIcon?: IconName;
+};
+declare const Switch: React__default.ForwardRefExoticComponent<SwitchProps & {
+    children?: React__default.ReactNode | undefined;
+} & React__default.RefAttributes<HTMLButtonElement>>;
+
+type ItemProps = {
+    /**
+     * Id único que identifica o switch.
+     */
+    id?: string;
+    /**
+     * Especifica o valor que o switch deve ter.
+     */
+    value: string;
+    /**
+     * Texto que será renderizada ao lado do radio.
+     */
+    children: string;
+    /**
+     * Especifica se o componente deve estar desabilitado.
+     */
+    disabled?: boolean;
+};
+declare function RadioGroupItem(props: PropsWithChildren<ItemProps>): react_jsx_runtime.JSX.Element;
+
+type RadioGroupProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    /**
+     * Especifica se o componente deve estar desabilitado.
+     */
+    disabled?: boolean;
+    /**
+     * Valor padrão com o qual o componente será renderizado.
+     */
+    defaultValue?: string;
+    /**
+     * Valor selecionado.
+     */
+    value?: string;
+    /**
+     * Executa função quando o radio é selecionado
+     */
+    onRadioChange?: (e: string) => void;
+    /**
+     * Especifica se o grupo deve ser renderizado em linha ao
+     * invés de coluna
+     */
+    row?: boolean;
+};
+declare function RadioGroup({ onRadioChange, value, ...rest }: React.PropsWithChildren<RadioGroupProps>): react_jsx_runtime.JSX.Element;
+declare namespace RadioGroup {
+    var Item: typeof RadioGroupItem;
+}
+
+type RequiredSwitchProps = Required<Pick<SwitchProps, 'name'>>;
+declare function FilterSwitch(props: SwitchProps & RequiredSwitchProps & {
+    compact?: boolean;
+}): react_jsx_runtime.JSX.Element;
+
+type Rules = {
+    /**
+     * Determina se o input é obrigatório ou não, e caso falhe na validação
+     * irá exibir a mensagem `message` como um erro abaixo do input
+     * com o qual está relacionado.
+     */
+    required?: {
+        value: boolean;
+        message: string;
+    };
+    /**
+     * Determina o tamanho máximo, e caso falhe na validação
+     * irá exibir a mensagem `message` como um erro abaixo do input
+     * com o qual está relacionado.
+     */
+    maxLength?: {
+        value: number;
+        message: string;
+    };
+    /**
+     * Determina o tamanho mínimo, e caso falhe na validação
+     * irá exibir a mensagem `message` como um erro abaixo do input
+     * com o qual está relacionado.
+     */
+    minLength?: {
+        value: number;
+        message: string;
+    };
+    /**
+     * Determina padrão que o input deve obdecer, e caso falhe na validação
+     * irá exibir a mensagem `message` como um erro abaixo do input
+     * com o qual está relacionado.
+     */
+    pattern?: {
+        value: RegExp;
+        message: string;
+    };
+    /**
+     * Você pode passar uma função de callback diretamente para validar ou pode
+     * passar um objeto com múltiplas funções que serão utilizadas para validação.
+     *
+     * Para inputs que são objetos e arrays, é recomendável utilizar essa propriedade
+     * para validações, uma vez que as outras regras se aplicam principalmente aos tipos
+     * `string`, `number` e `boolean`.
+     *
+     * Caso a função de callback retorne true, significa que o input é valido, e caso
+     * retorne uma string com uma mensagem, essa mensagem será utiliza para exeibit uma
+     * mensagem de erro abaixo do input.
+     */
+    validate?: ((value?: any) => true | string) | Record<string, (value?: any) => true | string>;
+};
+
+type RequiredTextInputProps$2 = Required<Pick<DatePickerProps, 'name'>>;
+declare function FilterDatePicker(props: DatePickerProps & RequiredTextInputProps$2 & {
+    rules?: Rules;
+}): react_jsx_runtime.JSX.Element;
+
+type RequiredTextInputProps$1 = Required<Pick<SelectProps, 'name'>>;
+declare function FilterSelect(props: SelectProps & RequiredTextInputProps$1 & {
+    rules?: Rules;
+}): react_jsx_runtime.JSX.Element;
+
+type RequiredTextInputProps = Required<Pick<TextInputProps, 'name'>>;
+declare function FilterTextInput(props: TextInputProps & RequiredTextInputProps & {
+    rules?: Rules;
+}): react_jsx_runtime.JSX.Element;
+
+type FilterTag = {
+    label: string;
+    value?: string;
+};
+type FilterProps<T> = {
+    /**
+     * Componentes filhos. Para maior facilidade de uso do `Filter`, recomendamos
+     * usar os componentes que estão especificados na documentação e são acessados através
+     * de `Filter.ComponenteFilho`.
+     */
+    children: React__default.ReactNode;
+    /**
+     * Evento disparado ao submeter o formulário.
+     */
+    onSubmit?: (formData: T) => unknown;
+    /**
+     * Evento disparado ao limpar o formulário. O `formData` recebido é um objeto
+     * com os últimos valores presentes no formulario antes do reset.
+     */
+    onClear?: (formData: T) => unknown;
+    /**
+     * Indica se o formulário está em estado de loading.
+     */
+    loading?: boolean;
+    /**
+     * Recebe uma listagem dos filtros ativos.
+     */
+    activeFilters?: FilterTag[];
+    /**
+     * Controla o estado de abertura do filtro
+     */
+    expanded?: boolean;
+    /**
+     * Função disparada ao expandir o filtro
+     */
+    onExpand?: (nextValue: boolean) => void;
+    /**
+     * Indica se o título deve ser exibido ou não.
+     */
+    showTitle?: boolean;
+    /**
+     * Define o container pai onde o dropdown menu criado será renderizado
+     * @default document.body
+     */
+    containerRef?: React__default.RefObject<HTMLElement>;
+    /**
+     * Indica se o filtro deve fechar automaticamente após todas as buscas
+     */
+    closeOnSubmit?: boolean;
+    /**
+     * Indica se o filtro deve preservar os dados quando clicado em limpar
+     * @default true
+     */
+    preserveDefaultValuesOnClear?: boolean;
+};
+type FilterHandle = {
+    clearField: (key: string) => void;
+    refetch: () => Promise<void>;
+};
+declare const Filter: (<T extends Record<string, any>>(props: FilterProps<T> & React__default.RefAttributes<FilterHandle>) => JSX.Element) & {
+    TextInput: typeof FilterTextInput;
+    Select: typeof FilterSelect;
+    DatePicker: typeof FilterDatePicker;
+    Switch: typeof FilterSwitch;
+};
+
+type TooltipOwnProps = {
+    /**
+     * Especifica se a seta do tooltip deve ser mostrado ou não
+     */
+    arrow?: boolean;
+    /**
+     * Especifica a mensagem do tooltip
+     */
+    message?: string;
+    /**
+     * Especifica a posição da seta
+     */
+    align?: 'start' | 'center' | 'end';
+    /**
+     * Especifica qual lado o tooltip será mostrado
+     */
+    position?: 'top' | 'right' | 'bottom' | 'left';
+    /**
+     * Define o container pai onde o menu será renderizado
+     * @default document.body
+     */
+    containerRef?: React.RefObject<HTMLDivElement>;
+    /**
+     * Especifica se o tooltip deve passar as props diretamente para o children
+     * ou passar para uma div ao redor
+     */
+    asChild?: boolean;
+    /**
+     * Mensagem do tooltip renderizada como HTML
+     */
+    htmlMessage?: React.ReactNode;
+};
+type TooltipProps = Combine<RadixToolTip.TooltipProps, TooltipOwnProps>;
+declare function Tooltip({ arrow, children, position, align, message, htmlMessage, containerRef, asChild, ...rest }: TooltipProps): react_jsx_runtime.JSX.Element;
+
+declare function Toasts(): react_jsx_runtime.JSX.Element;
+declare const toast: {
+    success: (title: string | {
+        title: string;
+        description: string;
+    }) => void;
+    warning: (title: string | {
+        title: string;
+        description: string;
+    }) => void;
+    info: (title: string | {
+        title: string;
+        description: string;
+    }) => void;
+    danger: (title: string | {
+        title: string;
+        description: string;
+    }) => void;
+    severeWarning(title: string | {
+        title: string;
+        description: string;
+    }): void;
+};
+
+type SkeletonProps = {
+    /**
+     * Define a quantidade de linhas iguais a serem renderizadas
+     */
+    rows?: number;
+    /**
+     * Define a altura da linha
+     */
+    height?: number | string;
+    /**
+     * Define a largura da linha
+     */
+    width?: number | string;
+    /**
+     * Define se o componente deve ser renderizado em linha. Por padrão uma tag <br /> é inserida entre as linhas
+     */
+    inline?: boolean;
+    /**
+     * Estilos customizados que serão aplicados ao componente
+     */
+    style?: React.CSSProperties;
+    /**
+     * Define o border radius da linha
+     */
+    borderRadius?: string | number;
+    /**
+     * className customizada que será aplicada ao componente
+     */
+    className?: string;
+    /**
+     * Define um skeleton para representar uma variante de texto do componente Typography
+     */
+    as?: Variant$3;
+};
+declare function Skeleton({ rows, height, width, inline, style, borderRadius, className, as, }: SkeletonProps): react_jsx_runtime.JSX.Element;
+
+type LinkRenderComponentProps = {
+    href: string;
+    children: React.ReactNode;
+};
+type LinkProps = {
+    /**
+     * Define a variante do componente
+     */
+    variant?: 'default' | 'small' | 'large';
+    /**
+     * Prop para especificar a url de destino.
+     */
+    href: string;
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    inline?: boolean;
+    /**
+     * Função utilizada para renderizar um componente customizado
+     * que será responsável pela navegação.
+     */
+    renderComponent?: ({ href, children, }: LinkRenderComponentProps) => JSX.Element;
+    /**
+     * Especifica um tipo de ícone pré-definido que deve ser
+     * renderizado dentro do Button.
+     */
+    icon?: IconName;
+    /**
+     * Especifica a posição dos ícones que fazem parte do botão.
+     * A posição afeta o ícone de loading e o ícone dentro do botão,
+     * caso seja passado a prop `icon` ou `renderIcon`.
+     */
+    iconPosition?: 'left' | 'right';
+    /**
+     * Prop que permite que o usuário possa renderizar um ícone customizado
+     * que não está previsto nos ícones pré-definidos da props `icon`.
+     */
+    renderIcon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;
+} & React.AnchorHTMLAttributes<HTMLAnchorElement>;
+declare function Link({ className, renderComponent, inline, href, children, renderIcon, icon, iconPosition, variant, ...rest }: React.PropsWithChildren<LinkProps>): react_jsx_runtime.JSX.Element;
+
+type NavigationMenuItemProps = {
+    /**
+     * Renderiza os componentes que formam um item do menu
+     * de navegação. O item pode ser um grupo, ou item único
+     */
+    children?: React.ReactNode;
+};
+declare function NavigationMenuItem({ children }: NavigationMenuItemProps): react_jsx_runtime.JSX.Element;
+
+type NavigationMenuLinkProps = {
+    /**
+     * Especifica qual o local para onde será navegado
+     */
+    href: string;
+    /**
+     * Renderiza um componente filho que servirá como componente
+     * de navegação. Se não for passado nenhum elemento, apenas
+     * um texto simples, o componente renderizado será uma `<a></a>`.
+     * Se for preciso usar um componente customizado de roteamento,
+     * ele deve ser passado como children.
+     */
+    children: React__default.ReactNode;
+    /**
+     * Especifica se o link deve estar desabilitado.
+     */
+    disabled?: boolean;
+    /**
+     * Especifica se o link está ativo. Útil para indicar
+     * a página atual para o usuário.
+     */
+    active?: boolean;
+    /**
+     * Evento disparado ao clicar no link
+     */
+    onSelect?: (event: Event) => void;
+    renderComponent?: (props: {
+        href: string;
+        children?: React__default.ReactNode;
+    }) => JSX.Element;
+};
+declare function NavigationMenuLink({ children, href, disabled, active, onSelect, renderComponent, }: NavigationMenuLinkProps): react_jsx_runtime.JSX.Element;
+
+type NavigationMenuGroupProps = {
+    /**
+     * Descreve nome do grupo de múltiplos links
+     */
+    label: string;
+    /**
+     * Renderiza os componentes que formam o menu de
+     * navegação
+     */
+    children: React.ReactElement<{
+        active?: boolean;
+    }>[];
+    /**
+     * Especifica se o grupo, como um todo, deve estar desabilitado.
+     * Caso seja necessário desabilitar apenas um dos links do grupo,
+     * o controle deve ser feito no componente do link, e não do grupo.
+     */
+    disabled?: boolean;
+};
+declare function NavigationMenuGroup({ children, disabled, label, }: NavigationMenuGroupProps): react_jsx_runtime.JSX.Element;
+
+type NavigationMenuProps = {
+    /**
+     * Renderiza os componentes que formam o menu de
+     * navegação
+     */
+    children?: React.ReactNode;
+};
+declare function NavigationMenu({ children }: NavigationMenuProps): react_jsx_runtime.JSX.Element;
+declare namespace NavigationMenu {
+    var Item: typeof NavigationMenuItem;
+    var Link: typeof NavigationMenuLink;
+    var Group: typeof NavigationMenuGroup;
+}
+
+type BreadcrumbsProps = {
+    /**
+     * Elementos que serão utilizados para representar cada
+     * item do breadcrumb. Idealmente devem ser elementos de navegação
+     * que irão depender da implementação de rotas das aplicações.
+     * Por exemplo: no caso de uso do `react-router-dom`, essa props
+     * irá receber um array de elementos `Link` da própria lib.
+     */
+    crumbs: React.ReactNode[];
+};
+declare function Breadcrumbs({ crumbs }: BreadcrumbsProps): react_jsx_runtime.JSX.Element;
+
+type Props = {
+    /**
+     * Especifica componente que será renderizado quando não houver
+     * erro
+     */
+    children?: React__default.ReactNode;
+    /**
+     * Especifica componente que será renderizado quando houver
+     * erro
+     */
+    fallback?: React__default.ReactNode;
+    /**
+     * Evento disparado quando houver um erro
+     */
+    onError?: (error: Error, info: any) => void | Promise<void>;
+    /**
+     *
+     */
+    shouldUpdate?: boolean;
+};
+type State = {
+    hasError?: boolean;
+};
+declare class ErrorBoundary extends React__default.Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(): {
+        hasError: boolean;
+    };
+    componentDidUpdate(prevProps: Props): void;
+    componentDidCatch(error: Error, info: any): void;
+    render(): string | number | boolean | react_jsx_runtime.JSX.Element | Iterable<React__default.ReactNode>;
+}
+
+type NeedPermissionProps = {
+    /**
+     * Define se o componente estará no estado de desabilitado ou não.
+     * Caso esteja desabilitado, irá renderizar um Tooltip com mensagem
+     * informando que o usuário não tem permissão para acessar o componente.
+     */
+    allowed?: boolean;
+    /**
+     * Componente filho que estará no estado de desabilitado caso o usuário
+     * não tenha permissão.
+     */
+    children: React__default.ReactElement;
+    /**
+     * Determina se o componente está no estado de loading ou não. Caso esteja
+     * no estado de loading, renderiza o fallback especificado na prop `fallback`.
+     */
+    loading?: boolean;
+    /**
+     * Componente React renderizado como fallback. Útil para mostrar estado
+     * de loading enquanto é feita consulta à API para saber se o usuário
+     * tem as devidas ppermissões
+     */
+    fallback?: React__default.ReactNode;
+};
+declare function NeedPermission({ children, loading, allowed, fallback, }: NeedPermissionProps): react_jsx_runtime.JSX.Element;
+
+type Variant$2 = 'warning' | 'info' | 'success' | 'danger' | 'severe-warning';
+type BadgeOwnProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    /**
+     * Especifica o tipo de Badge que será renderizado.
+     */
+    variant: Variant$2;
+    /**
+     * Especifica um tipo de ícone pré-definido que deve ser
+     * renderizado dentro do Badge.
+     */
+    icon?: IconName;
+    /**
+     * Prop que permite que o usuário possa renderizar um ícone customizado
+     * que não está previsto nos ícones pré-definidos da props `icon`.
+     */
+    renderIcon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;
+    /**
+     * Especifica se o Badge e do tipo Dot, a onde será redenrizado um componente
+     * no estilo de um circulo.
+     */
+    isDot?: boolean;
+    /**
+     * Especifica se o Badge e do tipo Contador, a onde será redenrizado um componente
+     * no estilo de counter.
+     */
+    isCounter?: boolean;
+};
+type BadgeProps = Combine<React.HTMLAttributes<HTMLElement>, BadgeOwnProps>;
+declare function Badge({ variant, children, className, icon, isDot, renderIcon, isCounter, ...rest }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+type Variant$1 = 'success' | 'info' | 'warning' | 'danger' | 'severe-warning';
+type BannerProps = {
+    /**
+     * Mensagem que será exibida como conteúdo do Banner.
+     */
+    children: string;
+    /**
+     * Especifica o tipo de Button que será renderizado.
+     */
+    variant: Variant$1;
+    /**
+     * Especifica um tipo de ícone pré-definido que deve ser
+     * renderizado dentro do Banner.
+     */
+    icon?: IconName;
+    /**
+     * Callback executado ao clicar no botão de 'fechar'.
+     */
+    onClose?: () => void;
+    /**
+     * Adiciona um botão de ação extra ao Banner.
+     */
+    action?: {
+        label: string;
+        onClick: () => void;
+        closeOnAction?: boolean;
+    };
+    /**
+     * Adiciona um link ao fim da mensagem do Banner.
+     */
+    link?: {
+        label: string;
+        url: string;
+    };
+    /**
+     * Controla a visibilidade do Banner.
+     */
+    open?: boolean;
+    /**
+     * Classes customizadas para o componente.
+     */
+    className?: string;
+    /**
+     * Distanciamento superior em relação ao topo da página.
+     */
+    top?: number;
+    /**
+     * Distanciamento lateral esquerdo em relação ao lado esquerdo da página.
+     */
+    left?: number;
+    /**
+     * Distanciamento lateral direito em relação ao lado direito da página.
+     */
+    right?: number;
+    /**
+     * Define o posicionamento do banner como inline.
+     */
+    inline?: boolean;
+};
+declare function Banner(props: BannerProps): react_jsx_runtime.JSX.Element;
+
+type Variant = 'success' | 'info' | 'warning' | 'danger' | 'severe-warning';
+type AlertProps = {
+    /**
+     * título do alert.
+     */
+    title: string;
+    /**
+     * Mensagem que será exibida como conteúdo do alert.
+     */
+    children: string;
+    /**
+     * Especifica o tipo de Button que será renderizado.
+     */
+    variant: Variant;
+    /**
+     * Callback executado ao clicar no botão de 'fechar'.
+     */
+    onClose?: () => void;
+    /**
+     * Adiciona um botão de ação extra ao alert.
+     */
+    link?: {
+        label: string;
+        url: string;
+    };
+    /**
+     * Controla a visibilidade do alert.
+     */
+    open?: boolean;
+    /**
+     * Define o posicionamento do banner como inline.
+     */
+    inline?: boolean;
+    /**
+     * Classes customizadas para o componente.
+     */
+    className?: string;
+};
+declare function Alert(props: AlertProps): react_jsx_runtime.JSX.Element;
+
+type ToolbarControl = 'FONT_STYLE' | 'FONT_COLOR' | 'TEXT_ALIGN' | 'LIST' | 'HISTORY' | 'CLIPBOARD' | 'MEDIA_LINK';
+
+type TextToolbarProps = {
+    /**
+     * Habilita a altura mínima do editor de `400px`
+     * @default true
+     */
+    minHeight?: boolean;
+    /**
+     * Habilita o scroll do editor quando o conteúdo ultrapassa a
+     * altura máxima de `400px`
+     * @default false
+     */
+    scrollable?: boolean;
+    /**
+     * Exibe o menu de opções do editor em formato de balão quando uma linha é selecionada
+     * @default false
+     */
+    menuBubble?: boolean;
+    /**
+     * Limitador de caracteres do editor
+     */
+    charLimit?: number;
+    /**
+     * Exibe o limitador de caracteres do editor
+     * @default false
+     */
+    showLimit?: boolean;
+    /**
+     * Placeholder exibido no editor quando não há conteúdo
+     * @default 'Digite aqui...'
+     */
+    placeholder?: string;
+    /**
+     * Conteúdo para o editor, pode-se passar tanto `HTML` quanto `JSON`
+     * saiba mais em https://tiptap.dev/docs/editor/api/editor#content
+     */
+    content?: EditorOptions['content'];
+    /**
+     * Desabilita a edição do editor e o torna somente leitura
+     */
+    readOnly?: boolean;
+    /**
+     * Função que é chamada sempre que o conteúdo do editor é alterado
+     * saiba mais em https://tiptap.dev/docs/editor/guide/output#listening-for-changes
+     */
+    onUpdate?: EditorOptions['onUpdate'];
+    /**
+     * Controles que serão exibidos no editor
+     * @default ['FONT_STYLE', 'FONT_COLOR', 'TEXT_ALIGN', 'LIST', 'HISTORY', 'CLIPBOARD', 'MEDIA_LINK']
+     */
+    controls?: ToolbarControl[];
+};
+declare function TextToolbar({ minHeight, readOnly, scrollable, charLimit, showLimit, placeholder, content, onUpdate, menuBubble, controls, }: TextToolbarProps): react_jsx_runtime.JSX.Element;
+
+type TimelineContainerProps = {
+    children: Array<ReactNode> | ReactNode;
+};
+declare function TimelineContainer({ children }: TimelineContainerProps): react_jsx_runtime.JSX.Element;
+
+declare function TimelineContent({ children }: React__default.PropsWithChildren): react_jsx_runtime.JSX.Element;
+
+type TimelineDotProps = {
+    /**
+     * Deixa o ponto com uma cor mais forte
+     * demostrando que o ponto está ativo
+     */
+    active?: boolean;
+    /**
+     * Número a qual vai ficar dentro do ponto
+     */
+    dotNumber?: number;
+    /**
+     * Não mostra a linha de continuidade do timeline
+     */
+    end?: boolean;
+    /**
+     * Função de manipulação de clique a qual é executada
+     * quando é realizado o clique no ponto
+     */
+    onClick?: () => void;
+    /**
+     * Nome do ícone a qual vai ficar dentro do ponto
+     */
+    icon?: IconName;
+    /**
+     * Aplica uma cor dentre as variantes ao Dot
+     */
+    variant?: 'danger' | 'severe-warning' | 'warning' | 'active' | 'disabled';
+};
+declare function TimelineDot({ active, dotNumber, end, onClick: handleClick, icon, variant, }: TimelineDotProps): react_jsx_runtime.JSX.Element;
+
+type TimelineLeftProps = {
+    /**
+     * Data do step ou evento
+     */
+    date: Date;
+};
+declare function TimelineLeft({ date }: TimelineLeftProps): react_jsx_runtime.JSX.Element;
+
+type TimelineRightProps = {
+    /**
+     * Título do step ou evento
+     */
+    title: string;
+    /**
+     * Propriedade de accordion a qual diz se
+     * deve-se mostrar ou não a descrição
+     */
+    showDescription?: boolean;
+    /**
+     * Descrição do step ou evento
+     */
+    description?: string;
+    /**
+     * O children deve ser passado entre
+     * a tag de abertura e a tag de fechamento
+     */
+    children?: ReactNode;
+};
+declare function TimelineRight({ title, showDescription, description, children, }: TimelineRightProps): react_jsx_runtime.JSX.Element;
+
+declare const Timeline: {
+    Container: typeof TimelineContainer;
+    Content: typeof TimelineContent;
+    Right: typeof TimelineRight;
+    Dot: typeof TimelineDot;
+    Left: typeof TimelineLeft;
+};
+
+type ProgressBarProps = {
+    /**
+     * Valor do progresso
+     */
+    progress: number;
+    /**
+     * Mostra com indicadores de cores o progresso
+     */
+    color?: boolean;
+};
+declare function ProgressBar({ progress: progressProps, color, children, }: React.PropsWithChildren<ProgressBarProps>): react_jsx_runtime.JSX.Element;
+
+type AvatarStatus = 'busy' | 'offline' | 'available';
+
+type AvatarProps = {
+    /**
+     * Especifica a URL da imagem que será renderizada dentro do avatar.
+     */
+    src: string;
+    /**
+     * Especifica o nome do avatar que será exibido no hover do avatar e
+     * usado para gerar a imagem do avatar caso a URL da imagem seja inválida.
+     */
+    name: string;
+    /**
+     * Prop que controla a visibilidade do children do avatar.
+     */
+    open?: boolean;
+    /**
+     * Evento disparado ao alterar a visibilidade do children do avatar
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Evento disparado ao clicar no avatar
+     */
+    onClick?: () => void;
+    /**
+     * Prop que controla o tamanho do avatar.
+     */
+    compact?: boolean;
+    /**
+     * Prop para definir o status do avatar.
+     */
+    status?: AvatarStatus;
+};
+declare function Avatar({ src, name, compact, status, open: openProps, onClick, onOpenChange, children, }: PropsWithChildren<AvatarProps>): react_jsx_runtime.JSX.Element;
+
+type StepProps = {
+    /**
+     * Título que será renderizado na StepperBar.
+     */
+    title: string;
+    /**
+     * Subtítulo secundário que será renderizado abaixo do título principal
+     */
+    subtitle?: string;
+    /**
+     * Especifica se o step deve estar completo ou não
+     */
+    completed?: boolean;
+    /**
+     * Especifica se o step é o atual ou não
+     */
+    current?: boolean;
+    /**
+     * Especifica se o step deve renderizar a label com o texto "Editado" no step ou não
+     */
+    edited?: boolean;
+    /**
+     * Especifica se o step deve estar desabilitado ou não
+     */
+    disabled?: boolean;
+    /**
+     * Especifica se o step deve estar em estado active ou não
+     */
+    active?: boolean;
+};
+declare function StepComponent({ children, }: React.PropsWithChildren<StepProps>): react_jsx_runtime.JSX.Element;
+
+type StepperProps = {
+    /**
+     * Recebe o children Step, deve ser passado entre
+     * a tag de abertura e a tag de fechamento.
+     */
+    children: React__default.ReactElement[];
+    /**
+     * Especifica se o Stepper deve ser linear.
+     */
+    linear?: boolean;
+    /**
+     * Especifica o step atual do array.
+     */
+    currentIndex?: number;
+    /**
+     * Evento disparado ao finalizar a etapa final do Stepper.
+     */
+    onFinish?: () => void;
+    /**
+     * Recebe uma label alternativa para o botão `próximo` no ultimo step.
+     * @default Finalizar
+     */
+    buttonText?: string;
+    /**
+     * Evento disparado para trocar de step. Utilizado quando é necessário
+     * ter um componente controlado.
+     */
+    onCurrentIndexChange?: (index: number) => void;
+};
+declare function Stepper({ children, linear, buttonText, currentIndex: currentIndexProp, onFinish, onCurrentIndexChange, }: StepperProps): react_jsx_runtime.JSX.Element;
+declare namespace Stepper {
+    var Step: typeof StepComponent;
+}
+
+type Action = {
+    /**
+     * Texto do botão de ação
+     */
+    label: string;
+} & Pick<ButtonProps, 'variant' | 'onClick'>;
+type CardActionsProps = {
+    primaryAction?: Action;
+    secondaryAction?: Action;
+};
+
+type CardContentProps = {
+    /**
+     * Conteúdo do card. Pode ser qualquer elemento ou componente
+     */
+    children: React.ReactNode;
+};
+declare function CardContent({ children }: CardContentProps): react_jsx_runtime.JSX.Element;
+
+type CardHeaderProps = {
+    /**
+     * Titulo do card
+     */
+    title: string;
+    /**
+     * Subtitulo do card
+     */
+    subTitle?: string;
+    /**
+     * evento disparado quando a seleção do checkbox é alterada.
+     * O checkbox só será renderizado se essa propriedade for passada.
+     */
+    onCheckedChange?: (checked: boolean) => void;
+    /**
+     * Opções para a lista suspensa de opções menos relevantes do card.
+     */
+    moreOptions?: {
+        label: string;
+        onSelect: (event: Event) => void;
+    }[];
+};
+declare function CardHeader({ subTitle, title, onCheckedChange, moreOptions, }: CardHeaderProps): react_jsx_runtime.JSX.Element;
+
+type CardImageProps = {
+    /**
+     * Url da imagem do card
+     */
+    src: string;
+    /**
+     * Texto alternativo da imagem
+     */
+    alt: string;
+};
+declare function CardImage({ src, alt }: CardImageProps): react_jsx_runtime.JSX.Element;
+
+type CardTagProps = TagProps;
+declare function CardTag(props: CardTagProps): react_jsx_runtime.JSX.Element;
+
+type CardProps = {
+    /**
+     * Conteúdo do card. Deve ser composto por um ou mais dos
+     * componentes: `Card.Header`, `Card.Image`, `Card.Tag`, `Card.Content` e `Card.Actions`
+     */
+    children: React__default.ReactNode;
+} & CardActionsProps;
+declare function Card({ children, primaryAction, secondaryAction }: CardProps): react_jsx_runtime.JSX.Element;
+declare namespace Card {
+    var Header: typeof CardHeader;
+    var Image: typeof CardImage;
+    var Tag: typeof CardTag;
+    var Content: typeof CardContent;
+}
+
+type DividerProps = {
+    /**
+     * Especifica a orientação que que o Divider deve ser renderizado.
+     */
+    orientation?: 'vertical' | 'horizontal';
+    /**
+     * Classes customizadas para o componente.
+     */
+    className?: string;
+    /**
+     * Objeto de estilo que pode ser utilizado para estilizar o componente.
+     */
+    style?: React.CSSProperties;
+};
+declare function Divider({ orientation, className, style, }: DividerProps): react_jsx_runtime.JSX.Element;
+
+type VariantColors = 'success' | 'warning' | 'severe-warning' | 'danger' | 'info';
+
+type ActionOption = {
+    label: string;
+    onSelect: (event: Event) => void;
+    icon?: IconName;
+};
+type TotalCardActionsProps = {
+    onUpdateCardData?: () => void;
+    options?: Array<ActionOption>;
+    showOpenDescription?: boolean;
+    onOpenDescription?: () => void;
+};
+
+type TotalCardMetricsProps = {
+    /**
+     * Indica se o card está em estado de carregamento
+     */
+    loading?: boolean;
+    /**
+     * Tipo da métrica
+     * @default good
+     */
+    type?: 'good' | 'bad';
+    /**
+     * Indica a direção da tendência da métrica
+     * @default up
+     */
+    trending?: 'up' | 'down';
+    /**
+     * Porcentagem da tendência da métrica
+     */
+    percent?: number;
+    /**
+     * Dias da tendência da métrica
+     */
+    days?: number;
+};
+
+declare function TotalCardGroup({ children }: PropsWithChildren): react_jsx_runtime.JSX.Element;
+
+type TotalCardProps = {
+    /**
+     * Título do card
+     */
+    title: string;
+    /**
+     * Valor numérico principal do card
+     */
+    value: number | string;
+    /**
+     * Ícone do card
+     */
+    icon: IconName;
+    /**
+     * Valor secundário do card. Exibido abaixo do valor principal
+     */
+    subValue?: string;
+    /**
+     * Cor do status do card
+     */
+    variant?: VariantColors;
+    /**
+     * Define as métricas exibidas na parte inferior do card
+     */
+    metric?: Exclude<TotalCardMetricsProps, 'loading'>;
+    /**
+     * Opções das ações exibidas no Dropdown do card
+     */
+    moreOptions?: ActionOption[];
+    /**
+     * Indica se o card está em estado de carregamento
+     */
+    loading?: boolean;
+    /**
+     * Conteúdo exibido no modal de descrição do card
+     */
+    children?: React.ReactNode;
+} & Pick<TotalCardActionsProps, 'onUpdateCardData'>;
+declare function TotalCard({ variant, metric, title, value, subValue, icon, loading, onUpdateCardData, moreOptions, children, }: TotalCardProps): react_jsx_runtime.JSX.Element;
+declare namespace TotalCard {
+    var Group: typeof TotalCardGroup;
+}
+
+type DialogProps = ModalProps & Pick<ModalContentWrapperProps, 'title' | 'onClose' | 'children' | 'cancelLabel'> & Required<Pick<ModalContentWrapperProps, 'action'>> & {
+    /**
+     * Prop para controlar a exibição do checkbox "Não mostrar novamente até a próxima sessão"
+     */
+    showDontShowAgain?: boolean;
+    /**
+     * Função que é chamada quando o checkbox "Não mostrar novamente até a próxima sessão" é alterado
+     */
+    onDontShowAgainChange?: (checked: boolean) => void;
+};
+declare function Dialog({ onOpenChange, open, children, showDontShowAgain, onDontShowAgainChange, ...rest }: DialogProps): react_jsx_runtime.JSX.Element;
+
+type StarRatingValue = 1 | 2 | 3 | 4 | 5;
+type StarRatingProps = {
+    /**
+     * O valor padrão do rating.
+     */
+    defaultRating?: StarRatingValue;
+    /**
+     * Função chamada quando o rating é alterado.
+     */
+    onChange?: (rating: StarRatingValue) => void;
+    /**
+     * Se o rating é somente leitura.
+     */
+    readOnly?: boolean;
+};
+
+type SimpleRatingValue = 'like' | 'dislike';
+type SimpleRatingProps = {
+    /**
+     * O valor padrão do rating.
+     */
+    defaultRating?: SimpleRatingValue;
+    /**
+     * Função chamada quando o rating é alterado.
+     */
+    onChange?: (rating: SimpleRatingValue) => void;
+    /**
+     * Se o rating é somente leitura.
+     */
+    readOnly?: boolean;
+};
+declare function SimpleRating({ defaultRating, onChange, readOnly, }: SimpleRatingProps): react_jsx_runtime.JSX.Element;
+
+type SatisfactionRatingValue = 'extremely-dissatisfied' | 'dissatisfied' | 'neutral' | 'satisfied' | 'very-satisfied';
+type SatisfactionRatingProps = {
+    /**
+     * O valor padrão do rating.
+     */
+    defaultRating?: SatisfactionRatingValue;
+    /**
+     * Função chamada quando o rating é alterado.
+     */
+    onChange?: (rating: SatisfactionRatingValue) => void;
+    /**
+     * Se o rating é somente leitura.
+     */
+    readOnly?: boolean;
+};
+declare function SatisfactionRating({ defaultRating, onChange, readOnly, }: SatisfactionRatingProps): react_jsx_runtime.JSX.Element;
+
+type NumericRatingValue = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+type NumericRatingProps = {
+    /**
+     * O valor padrão do rating.
+     */
+    defaultRating?: NumericRatingValue;
+    /**
+     * Função chamada quando o rating é alterado.
+     */
+    onChange?: (rating: NumericRatingValue) => void;
+    /**
+     * Se o rating é somente leitura.
+     */
+    readOnly?: boolean;
+};
+declare function NumericRating({ defaultRating, onChange, readOnly, }: NumericRatingProps): react_jsx_runtime.JSX.Element;
+
+type RatingProps = StarRatingProps;
+declare function Rating(props: RatingProps): react_jsx_runtime.JSX.Element;
+declare namespace Rating {
+    var Simple: typeof SimpleRating;
+    var Satisfaction: typeof SatisfactionRating;
+    var Numeric: typeof NumericRating;
+}
+
+type TabsItemProps = {
+    /**
+     * Especifica um value que servirá como identificação para a Tab.
+     */
+    value: string;
+    /**
+     * Especifica se a Tab deve estar desabilitada ou não.
+     */
+    disabled?: boolean;
+    /**
+     * Especifica um texto que deve ser exibido em um
+     * Tooltip renderizado acima da Tab.
+     */
+    description?: string;
+    /**
+     * Especifica um tipo de ícone pré-definido que deve ser
+     * renderizado dentro da Tab.
+     */
+    icon?: IconName;
+};
+declare function TabsItem({ children, value, description, disabled, icon, }: React__default.PropsWithChildren<TabsItemProps>): react_jsx_runtime.JSX.Element;
+
+type TabsHeaderProps = {
+    /**
+     * Conteúdo do Tabs. Deve ser composto por um ou mais dos
+     * componentes: `Tabs.Item`
+     */
+    children: React__default.ReactNode;
+};
+declare function TabsHeader({ children }: TabsHeaderProps): react_jsx_runtime.JSX.Element;
+
+type TabsContentProps = {
+    /**
+     * Recebe um value que servirá como identificação para o Content
+     * Deve possuir o mesmo value do Tabs.Item para que seja interligada
+     */
+    value: string;
+    /**
+     * Classes customizadas para o componente.
+     */
+    className?: string;
+};
+declare function TabsContent({ children, value, className, }: React__default.PropsWithChildren<TabsContentProps>): react_jsx_runtime.JSX.Element;
+
+type TabsProps = {
+    /**
+     * Especifica a orientação que o componente será renderizado.
+     * @default horizontal
+     */
+    orientation?: 'horizontal' | 'vertical';
+    /**
+     * Deve receber o value referente a Tab que será exibida.
+     */
+    defaultValue?: string;
+    /**
+     * Evento disparado para trocar de Tab. Utilizado quando é necessário
+     * ter um componente controlado.
+     */
+    onValueChange?: (value: string) => void;
+    /**
+     * Deve receber o value referente a Tab que será exibida. Utilizado quando é necessário
+     * ter um componente controlado.
+     */
+    value?: string;
+    containerRef?: React__default.RefObject<HTMLDivElement>;
+};
+declare function Tabs({ children, orientation, value, defaultValue, onValueChange, containerRef, }: React__default.PropsWithChildren<TabsProps>): react_jsx_runtime.JSX.Element;
+declare namespace Tabs {
+    var Header: typeof TabsHeader;
+    var Item: typeof TabsItem;
+    var Content: typeof TabsContent;
+}
+
+type Unit = 'B' | 'KB' | 'MB' | 'GB' | 'TB' | 'PB' | 'EB' | 'ZB' | 'YB';
+declare enum FILE_ERROR {
+    LIMIT_EXCEEDED = "Limite excedido",
+    SIZE_TOO_LARGE = "Arquivo muito grande",
+    INVALID_TYPE = "Tipo de arquivo inv\u00E1lido",
+    UPLOAD = "Falha no upload do arquivo"
+}
+
+type UploadedFileResponse<T> = {
+    /**
+     * Objeto de uso interno, contendo as informações relacionadas ao arquivo
+     */
+    file: FileItem;
+    /**
+     * Corpo da resposta retornada pelo endpoint de upload dos arquivos
+     */
+    data: T | undefined;
+    /**
+     * Status HTTP da requisição de upload do arquivo
+     */
+    statusCode: number | undefined;
+    /**
+     * Erro da requisição de upload do arquivo
+     */
+    error: {
+        code?: string;
+        message: string;
+    } | undefined;
+};
+
+type UploadedFile<T> = Omit<UploadedFileResponse<T>, 'file'> & {
+    file: {
+        name: string;
+        extension: string;
+    };
+};
+
+type FileUploadProps<T> = {
+    /**
+     * URL da API para onde o BLOB dos arquivos serão enviados via POST.
+     */
+    url: string;
+    /**
+     * Callback acionado sempre que a lista de arquivos enviados é atualizada.
+     * @param uploadResults array contendo as respostas da API para cada arquivo, incluindo erros e informações do arquivo.
+     */
+    onUploadFiles: (uploadResults: UploadedFile<T>[]) => void;
+    /**
+     * Título exibido no topo do componente de upload de arquivos.
+     * @default 'Carregar arquivos'
+     */
+    title?: string;
+    /**
+     * Tamanho máximo permitido para cada arquivo, usado em conjunto com `maxSizeUnity`
+     */
+    maxSize?: number;
+    /**
+     * Unidade de medida para `maxSize`, determinando o tamanho máximo permitido para cada arquivo.
+     * @default 'MB'
+     */
+    maxSizeUnity?: Unit;
+    /**
+     * Lista de extensões de arquivos permitidos para upload.
+     */
+    accept?: string[];
+    /**
+     * Quantidade máxima de arquivos que podem ser enviados.
+     * @default Infinity
+     */
+    maxFiles?: number;
+    /**
+     * Descrição personalizada exibida na parte superior do componente de upload de arquivos.
+     */
+    description?: string;
+    /**
+     * Configuração customizada para a requisição de upload, compatível com a interface `RequestInit` do Fetch API.
+     */
+    requestConfig?: RequestInit;
+    /**
+     * Define uma lista de arquivos pré-carregados anteriormente
+     */
+    defaultFiles?: FileItemProp<T>[];
+    /**
+     * Classes customizadas para o componente.
+     */
+    className?: string;
+    /**
+     * Objeto de estilo para personalizar a aparência do container.
+     */
+    style?: React.CSSProperties;
+    /**
+     * Define a largura do componente
+     */
+    width?: string | number;
+};
+type FileItemProp<T> = {
+    name: string;
+    extension: string;
+    data?: T;
+};
+type FileItem = {
+    error?: FILE_ERROR;
+    extension: string;
+    file: File;
+    uploaded: boolean;
+    loading: boolean;
+};
+declare function FileUpload<T>(props: FileUploadProps<T>): react_jsx_runtime.JSX.Element;
+
+type ImageCarouselItemProps = {
+    /**
+     * URL da imagem a ser exibida no carrossel.
+     */
+    src: string;
+    /**
+     * Texto alternativo para a imagem, usado para acessibilidade e quando a imagem não pode ser carregada.
+     */
+    alt: string;
+    /**
+     * Descrição opcional da imagem que pode ser exibida junto a ela.
+     */
+    caption?: string;
+    /**
+     * Nome do ícone opcional que será exibido como prefixo na descrição da imagem.
+     */
+    icon?: IconName;
+    /**
+     * Define como a imagem será exibida no carrossel.
+     *
+     * - 'fill': A imagem preencherá todo o espaço disponível no container,
+     *          podendo ser cortada para se ajustar ao tamanho do container.
+     * - 'fit': A imagem será redimensionada para caber dentro do container,
+     *          preservando suas proporções e podendo deixar espaços vazios
+     *          nas laterais ou em cima e embaixo.
+     * @default 'fill'
+     */
+    view?: 'fill' | 'fit';
+};
+declare function ImageCarouselItem({ caption, alt, src, icon, view, }: ImageCarouselItemProps): react_jsx_runtime.JSX.Element;
+declare namespace ImageCarouselItem {
+    var displayName: string;
+}
+
+type ImageCarouselProps = {
+    /**
+     * Indica se a troca de imagens deve ocorrer automaticamente.
+     * @default true
+     */
+    autoPlay?: boolean;
+    /**
+     * Duração em segundos de exibição de cada imagem quando o `autoPlay` está ativo.
+     * @default 7
+     */
+    speed?: number;
+    /**
+     * Largura do carrossel. Pode ser um valor em pixels, porcentagem ou qualquer unidade de medida CSS.
+     * @default '400px'
+     */
+    width?: CSSProperties['width'];
+    /**
+     * Controla o comportamento de tela cheia do componente
+     */
+    mode?: 'default' | 'fullscreen';
+    /**
+     * Callback chamado quando o modo de exibição é alterado
+     */
+    onModeChange?: (mode: 'default' | 'fullscreen') => void;
+};
+declare function ImageCarousel({ children, mode, onModeChange, ...rest }: React.PropsWithChildren<ImageCarouselProps>): react_jsx_runtime.JSX.Element;
+declare namespace ImageCarousel {
+    var Item: typeof ImageCarouselItem;
+}
+
+type TooltipInfo$2<T> = {
+    title?: string;
+    description?: string;
+    customContent?: never;
+} | {
+    title?: never;
+    description?: never;
+    customContent: (props: T) => JSX.Element;
+};
+type PieChartProps<T> = {
+    /**
+     * Título principal exibido no topo do gráfico.
+     */
+    title: string;
+    /**
+     * Subtítulo opcional exibido abaixo do título principal, fornecendo informações adicionais.
+     */
+    subtitle?: string;
+    /**
+     * Define a orientação do gráfico. Aceita os valores 'vertical' ou 'horizontal'.
+     * Determina a disposição dos elementos visuais.
+     */
+    orientation?: 'vertical' | 'horizontal';
+    /**
+     * Array contendo os dados utilizados para construir o gráfico.
+     * Cada elemento do array representa um conjunto de informações.
+     */
+    data: T[];
+    /**
+     * Conteúdo personalizado para exibição em um modal de descrição detalhada.
+     * Aceita componentes React, permitindo total flexibilidade de layout e estilo.
+     */
+    descriptionContent?: ReactNode;
+    /**
+     * Altura do gráfico em pixels. Define o espaço vertical ocupado pelo componente.
+     */
+    height?: number;
+    /**
+     * Indica se o gráfico está em estado de carregamento.
+     * Pode ser usado para exibir um indicador de progresso enquanto os dados são processados.
+     */
+    loading?: boolean;
+    /**
+     * Função de callback acionada ao selecionar a opção de "Atualizar dados".
+     * Permite recarregar ou recalcular os dados exibidos no gráfico.
+     */
+    onUpdateData?: () => void;
+    /**
+     * Configuração personalizada para o Tooltip exibido ao interagir com o gráfico.
+     * Aceita informações detalhadas, incluindo componentes React para maior personalização.
+     */
+    tooltipContent?: TooltipInfo$2<T>;
+    /**
+     * Habilita ou desabilita a exibição de uma descrição detalhada do gráfico.
+     */
+    enableDescription?: boolean;
+    /**
+     * Determina se a funcionalidade de filtragem de dados está ativa no gráfico.
+     * @default true
+     */
+    enableFilter?: boolean;
+    /**
+     * Controla a exibição da opção de atualizar os dados do gráfico.
+     * @default true
+     */
+    enableUpdateData?: boolean;
+    /**
+     * Especifica a chave de um item no array `data` usada para identificar
+     * categorias no gráfico, como rótulos de legenda ou eixos.
+     */
+    categoryKey: keyof T;
+    /**
+     * Especifica a chave de um item no array `data` usada para identificar
+     * os valores associados às categorias no gráfico.
+     */
+    valueKey: keyof T;
+    /**
+     * Referência ao elemento HTML que será o container do menu dropdown gerado.
+     * @default document.body
+     */
+    containerRef?: React.RefObject<HTMLElement>;
+    /**
+     * Paleta de cores usada no gráfico. Pode ser o esquema padrão ou monocromático.
+     * @default 'default'
+     */
+    palette?: 'default' | 'monochromatic';
+    /**
+     * Objeto de estilo inline para personalização do estilo do componente.
+     */
+    style?: React.CSSProperties;
+    /**
+     * Função para aplicar formatação personalizada aos valores exibidos no gráfico.
+     * Pode ser usada para alterar a aparência ou formato dos números.
+     */
+    valueFormatter?: (value: number) => any;
+    /**
+     * Cores customizadas para cada barra do gráfico
+     */
+    customColors?: Partial<Record<string, string>>;
+};
+declare function PieChart<T>({ title, subtitle, orientation, data: dataProp, descriptionContent, style, height, onUpdateData, tooltipContent, categoryKey, valueKey, loading, enableDescription, enableFilter, enableUpdateData, containerRef, children, palette, valueFormatter, customColors, }: PropsWithChildren<PieChartProps<T>>): react_jsx_runtime.JSX.Element;
+
+type TooltipInfo$1<T> = {
+    title?: string;
+    description?: string;
+    customContent?: never;
+} | {
+    title?: never;
+    description?: never;
+    customContent: (props: T) => JSX.Element;
+};
+
+type BarChartData<T> = {
+    isProjection?: boolean;
+} & T;
+type BarChartProps<T> = {
+    /**
+     * Título principal exibido no topo do gráfico.
+     */
+    title: string;
+    /**
+     * Subtítulo opcional exibido abaixo do título principal, fornecendo informações complementares.
+     */
+    subtitle?: string;
+    /**
+     * Define a orientação do gráfico, podendo ser `horizontal` ou `vertical`.
+     * Afeta a disposição das barras no gráfico.
+     * @default 'horizontal'
+     */
+    orientation?: 'vertical' | 'horizontal';
+    /**
+     * Array de objetos contendo os dados a serem exibidos no gráfico.
+     * Cada item representa uma categoria e seus valores associados.
+     */
+    data: BarChartData<T>[];
+    /**
+     * Conteúdo personalizado exibido em um modal de descrição detalhada.
+     * Aceita componentes React para maior flexibilidade de layout.
+     */
+    descriptionContent?: ReactNode;
+    /**
+     * Altura do gráfico em pixels, definindo o espaço vertical ocupado.
+     */
+    height?: number;
+    /**
+     * Define a largura de cada barra no gráfico.
+     */
+    barSize?: number;
+    /**
+     * Rótulo exibido ao longo do eixo Y, indicando o significado dos valores representados.
+     */
+    yAxisLabel?: string;
+    /**
+     * Rótulo exibido ao longo do eixo X, indicando o significado das categorias.
+     */
+    xAxisLabel?: string;
+    /**
+     * Chave do objeto `data` usada para identificar as categorias no gráfico.
+     */
+    categoryKey: keyof T;
+    /**
+     * Chave do objeto `data` usada para identificar os valores associados às categorias.
+     */
+    valueKey: (keyof T)[];
+    /**
+     * Chave opcional do objeto `data` usada para identificar os valores de meta no gráfico.
+     */
+    metaKey?: keyof T;
+    /**
+     * Configuração do Tooltip exibido ao interagir com as barras do gráfico.
+     * Aceita título, descrição e componentes customizados para personalização.
+     */
+    tooltipContent?: TooltipInfo$1<T>;
+    /**
+     * Indica se o gráfico está em estado de carregamento, permitindo exibir um indicador visual.
+     */
+    loading?: boolean;
+    /**
+     * Função de callback acionada ao selecionar a opção "Atualizar dados".
+     * Permite recarregar ou recalcular os dados exibidos no gráfico.
+     */
+    onUpdateData?: () => void;
+    /**
+     * Controla a exibição da descrição detalhada do gráfico.
+     */
+    enableDescription?: boolean;
+    /**
+     * Habilita ou desabilita a funcionalidade de filtragem de dados no gráfico.
+     */
+    enableFilter?: boolean;
+    /**
+     * Controla a exibição da funcionalidade para atualizar os dados do gráfico.
+     */
+    enableUpdateData?: boolean;
+    /**
+     * Componente personalizado que será renderizado abaixo do cabeçalho do gráfico.
+     */
+    customComponent?: ReactNode;
+    /**
+     * Objeto que mapeia as chaves de valores para os nomes exibidos na legenda do gráfico.
+     */
+    valueKeyLegendName?: Partial<Record<keyof T, string>>;
+    /**
+     * Referência ao elemento HTML que será o container do menu dropdown gerado.
+     * @default document.body
+     */
+    containerRef?: React.RefObject<HTMLElement>;
+    /**
+     * Objeto de estilo inline para personalizar a aparência do gráfico.
+     */
+    style?: React.CSSProperties;
+    /**
+     * Função para formatar os valores exibidos no gráfico.
+     * Útil para alterar a aparência ou adicionar prefixos/sufixos.
+     */
+    valueFormatter?: (value: number) => any;
+    /**
+     * Função para formatar os valores exibidos no eixo Y.
+     */
+    yAxisFormatter?: (value: any) => string;
+    /**
+     * Função para formatar os valores exibidos no eixo X.
+     */
+    xAxisFormatter?: (value: any) => string;
+    /**
+     * Define a paleta de cores usada no gráfico, podendo ser o esquema padrão ou monocromático.
+     * @default 'default'
+     */
+    palette?: 'default' | 'monochromatic';
+    /**
+     * Cores customizadas para cada barra do gráfico
+     */
+    customColors?: Partial<Record<keyof T, string>>;
+};
+declare function BarChart<T>({ title, subtitle, orientation, data: dataProp, descriptionContent, style, height, barSize, yAxisLabel, xAxisLabel, categoryKey, valueKey, tooltipContent, metaKey, loading, onUpdateData, enableDescription, enableFilter, enableUpdateData, customComponent, valueKeyLegendName, containerRef, valueFormatter, yAxisFormatter, xAxisFormatter, palette, customColors, }: BarChartProps<T>): react_jsx_runtime.JSX.Element;
+
+type TooltipInfo<T> = {
+    title?: string;
+    description?: string;
+    customContent?: never;
+} | {
+    title?: never;
+    description?: never;
+    customContent: (props: T) => JSX.Element;
+};
+
+type LineChartProps<T> = {
+    /**
+     * Título principal exibido no topo do gráfico.
+     */
+    title: string;
+    /**
+     * Subtítulo opcional exibido abaixo do título principal, fornecendo contexto adicional.
+     */
+    subtitle?: string;
+    /**
+     * Array contendo os dados utilizados para desenhar o gráfico.
+     * Cada elemento representa um ponto ou conjunto de valores no gráfico.
+     */
+    data: T[];
+    /**
+     * Conteúdo personalizado exibido em um modal de descrição detalhada.
+     * Aceita componentes React para maior flexibilidade de layout.
+     */
+    descriptionContent?: ReactNode;
+    /**
+     * Altura do gráfico em pixels, definindo o espaço vertical ocupado.
+     */
+    height?: number;
+    /**
+     * Rótulo exibido ao longo do eixo Y para indicar o significado dos valores.
+     */
+    yAxisLabel?: string;
+    /**
+     * Rótulo exibido ao longo do eixo X para indicar o significado das categorias.
+     */
+    xAxisLabel?: string;
+    /**
+     * Chave no objeto de `data` usada para identificar as categorias (eixo X ou legendas).
+     */
+    categoryKey: keyof T;
+    /**
+     * Array de chaves no objeto de `data` usadas para identificar os valores a serem plotados.
+     */
+    valueKey: (keyof T)[];
+    /**
+     * Configuração do Tooltip exibido ao interagir com os pontos do gráfico.
+     * Aceita título, descrição e componentes customizados para personalização.
+     */
+    tooltipContent?: TooltipInfo<T>;
+    /**
+     * Indica se o gráfico está em estado de carregamento, permitindo exibir um indicador visual.
+     */
+    loading?: boolean;
+    /**
+     * Função de callback acionada ao selecionar a opção "Atualizar dados".
+     * Permite recarregar ou recalcular os dados exibidos no gráfico.
+     */
+    onUpdateData?: () => void;
+    /**
+     * Controla a exibição da descrição detalhada do gráfico.
+     */
+    enableDescription?: boolean;
+    /**
+     * Habilita ou desabilita a funcionalidade de filtragem de dados no gráfico.
+     */
+    enableFilter?: boolean;
+    /**
+     * Controla a exibição da funcionalidade para atualizar os dados do gráfico.
+     */
+    enableUpdateData?: boolean;
+    /**
+     * Habilita ou desabilita a exibição de rótulos nos pontos de valor do gráfico.
+     */
+    showLabels?: boolean;
+    /**
+     * Objeto que mapeia as chaves de valores para os nomes a serem exibidos na legenda.
+     */
+    valueKeyLegendName?: Partial<Record<keyof T, string>>;
+    /**
+     * Referência ao elemento HTML que será o container do menu dropdown gerado.
+     * @default document.body
+     */
+    containerRef?: React.RefObject<HTMLElement>;
+    /**
+     * Paleta de cores usada no gráfico, podendo ser o esquema padrão ou monocromático.
+     * @default 'default'
+     */
+    palette?: 'default' | 'monochromatic';
+    /**
+     * Objeto de estilo inline para personalizar a aparência do gráfico.
+     */
+    style?: React.CSSProperties;
+    /**
+     * Função para formatar os valores exibidos no gráfico.
+     * Útil para alterar a aparência ou adicionar prefixos/sufixos.
+     */
+    valueFormatter?: (value: number) => any;
+    /**
+     * Função para formatar os valores exibidos no eixo Y.
+     */
+    yAxisFormatter?: (value: any) => string;
+    /**
+     * Função para formatar os valores exibidos no eixo X.
+     */
+    xAxisFormatter?: (value: any) => string;
+    /**
+     * Cores customizadas para cada linha do gráfico
+     */
+    customColors?: Partial<Record<keyof T, string>>;
+};
+declare function LineChart<T>({ title, subtitle, data: dataProp, descriptionContent, height, yAxisLabel, xAxisLabel, categoryKey, valueKey, tooltipContent, onUpdateData, loading, enableDescription, enableFilter, enableUpdateData, showLabels, containerRef, children, valueKeyLegendName, palette, style, valueFormatter, yAxisFormatter, xAxisFormatter, customColors, }: PropsWithChildren<LineChartProps<T>>): react_jsx_runtime.JSX.Element;
+
+type AdvancedSelectOption = {
+    name?: string;
+    value?: unknown;
+    enableDelete?: boolean;
+};
+
+type AdvancedSelectOwnProps = {
+    /**
+     * Lista de opções que serão exibidas no select.
+     */
+    options: AdvancedSelectOption[];
+    /**
+     * Define a largura do componente.
+     * Aceita qualquer valor válido da propriedade CSS `width`.
+     */
+    width?: CSSProperties['width'];
+    /**
+     * Permite sobrescrever estilos do container principal do componente.
+     */
+    style?: CSSProperties;
+    /**
+     * Evento disparado ao selecionar uma opção. Utilizado quando é necessário
+     * ter um componente controlado.
+     */
+    onChange?: (option: AdvancedSelectOption[] | null) => void;
+    /**
+     * Especifica valor selecionado. Utilizado quando é necessário
+     * ter um componente controlado.
+     */
+    value?: AdvancedSelectOption[] | null;
+    /**
+     * Especifica valor padrão que será utilizado na renderização inicial
+     */
+    defaultValue?: AdvancedSelectOption[] | null;
+    /**
+     * Id que será atribuído ao componente
+     */
+    id?: string;
+    /**
+     * Nome que será atribuído ao componente
+     */
+    name?: string;
+    /**
+      * Label que será renderizada acima do input. Por motivos
+      * de acessibilidade deve
+      ser utilizado em conjunto com a prop `id` ou `name`.
+      */
+    label?: string;
+    /**
+     * Especifica se um componente deve estar desabilitado ou não
+     */
+    disabled?: boolean;
+    /**
+     * Especifica se o componente deve ser compacto ou não.
+     * O modo compacto é um componente de input com padding reduzido.
+     */
+    compact?: boolean;
+    /**
+     * Renderiza um texto dentro do container, à esquerda do input. Não
+     * deve ser utilizado em conjunto com a prop `icon` ou `renderIcon`.
+     */
+    prefix?: string;
+    /**
+     * Especifica um tipo de ícone pré-definido que deve ser
+     * renderizado dentro do container, à esquerda do input.
+     */
+    icon?: IconName;
+    /**
+     * Prop que permite que o usuário possa renderizar um ícone customizado
+     * que não está previsto nos ícones pré-definidos da props `icon`.
+     */
+    error?: string;
+    /**
+     * Renderiza uma mensagem de informação logo abaixo do input.
+     * Se utilizada com a prop `error`, a prop `error` terá prioridade e
+     * irá sobrescrever a mensagem de `hint`.
+     */
+    hint?: string;
+    /**
+     * Permite renderizar um ícone customizado à esquerda do input.
+     * Não deve ser utilizado em conjunto com as props `icon` ou `prefix`.
+     */
+    renderIcon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;
+    /**
+     * Define se as opções devem ser exibidas com checkbox,
+     * permitindo seleção múltipla visual.
+     */
+    withCheckbox?: boolean;
+    /**
+     * Função responsável por determinar se uma nova opção
+     * pode ser criada com base no valor digitado pelo usuário.
+     */
+    canCreateOption?: (inputValue: string) => boolean;
+    /**
+     * Callback disparado quando o usuário cria uma nova opção.
+     * Deve retornar uma Promise para permitir controle de loading.
+     */
+    onCreateOption?: (label: string) => Promise<void>;
+    /**
+     * Callback disparado quando ocorre um erro ao criar uma nova opção.
+     */
+    onCreateError?: (e: any) => void;
+    /**
+     * Callback disparado ao solicitar a exclusão de uma opção.
+     * Deve retornar uma Promise para permitir controle de loading.
+     */
+    onDeleteOption?: (option: AdvancedSelectOption) => Promise<void>;
+};
+type AdvancedSelectProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange' | 'defaultValue'> & AdvancedSelectOwnProps;
+declare function AdvancedSelect({ style, width: widthProp, value: valueProps, defaultValue, onChange, options, withCheckbox, onCreateOption, canCreateOption, onCreateError, error: errorProps, onDeleteOption, ...rest }: AdvancedSelectProps): react_jsx_runtime.JSX.Element;
+
+type DrawerProps = {
+    /**
+     * Define se o componente está aberto ou fechado.
+     * Quando `true`, o drawer é exibido; quando `false`, ele é ocultado.
+     */
+    open: boolean;
+    /**
+     * Callback disparado ao solicitar o fechamento do drawer.
+     * Normalmente é chamado ao clicar no botão de fechar,
+     * no overlay (quando `maskClosable` estiver habilitado)
+     * ou ao pressionar a tecla `Esc`.
+     */
+    onClose: () => void;
+    /**
+     * Define o lado da tela a partir do qual o drawer será exibido.
+     * @default 'right'
+     */
+    placement?: 'left' | 'right';
+    /**
+     * Define o tamanho do drawer.
+     *
+     * Os tamanhos disponíveis são:
+     * - `sm` (296px): Ideal para formulários simples e ações rápidas.
+     * - `md` (376px): Tamanho padrão para a maioria dos casos de uso.
+     * - `lg` (462px): Indicado para conteúdos mais extensos e formulários complexos.
+     * - `xl` (872px): Ideal para visualização de documentos,
+     *   conteúdos detalhados e filtragens complexas.
+     *
+     * @default 'md'
+     */
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    /**
+     * Define a largura do drawer.
+     * Aceita qualquer valor válido da propriedade CSS `width`
+     * (por exemplo: `450px`, `40%`, `auto`).
+     */
+    width?: CSSProperties['width'];
+    /**
+     * Define se o drawer pode ser fechado ao clicar na máscara
+     * (overlay) que cobre o conteúdo da página.
+     * @default true
+     */
+    maskClosable?: boolean;
+    /**
+     * Define o título exibido no cabeçalho do drawer.
+     * Pode ser usado para identificar o conteúdo apresentado.
+     */
+    title?: string;
+    /**
+     * Define se o conteúdo interno do drawer deve ser destruído
+     * ao ser fechado.
+     * Quando `true`, o conteúdo é desmontado ao fechar o drawer;
+     * quando `false`, o conteúdo permanece montado no DOM.
+     * @default false
+     */
+    destroyOnClose?: boolean;
+    /**
+     * Força a renderização do conteúdo do drawer mesmo quando
+     * ele estiver fechado.
+     * Útil quando é necessário pré-renderizar o conteúdo
+     * ou manter estados internos.
+     * @default false
+     */
+    forceRender?: boolean;
+    /**
+     * Callback disparado após a conclusão da animação
+     * de abertura ou fechamento do drawer.
+     * Recebe como parâmetro o estado atual (`true` para aberto,
+     * `false` para fechado).
+     */
+    afterOpenChange?: (open: boolean) => void;
+};
+declare function Drawer({ open, onClose, children, maskClosable, title, destroyOnClose, forceRender, afterOpenChange, width: widthProp, placement, size, }: PropsWithChildren<DrawerProps>): react_jsx_runtime.JSX.Element;
+
+export { AdvancedSelect, AdvancedSelectOption, Alert, Avatar, BackToTop, Badge, Banner, BarChart, Breadcrumbs, Button, Card, Checkbox, Chip, DatePicker, Dialog, Divider, Drawer, DropdownMenu, ErrorBoundary, FileItemProp, FileUpload, FileUploadProps, Filter, FilterHandle, IconButton, ImageCarousel, LineChart, Link, LinkProps, LinkRenderComponentProps, Mask, Modal, ModalAction, MultilineTextInput, NavigationMenu, NeedPermission, PasswordInput, PieChart, ProgressBar, RadioGroup, Rating, Select, SelectOption, Skeleton, Stepper, Switch, Tabs, Tag, TextInput, TextToolbar, Timeline, Toasts, Tooltip, TotalCard, Typography, UploadedFile, toast };