@free-dom/react-components 2.0.0

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

@@ -0,0 +1,60 @@
+import * as Menu from '@radix-ui/react-dropdown-menu';
+import { IconName } from '@freedom/react-icons';
+import { DropdownMenuGroup } from './DropdownMenuGroup';
+import { DropdownMenuIcon } from './DropdownMenuIcon';
+import { DropdownMenuItem } from './DropdownMenuItem';
+import { DropdownMenuSeparator } from './DropdownMenuSeparator';
+import { DropdownMenuText } from './DropdownMenuText';
+import { DropdownMenuSub } from './DropdownMenuSub';
+export 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>): import("react/jsx-runtime").JSX.Element;
+declare namespace DropdownMenu {
+    var Content: import("react").ForwardRefExoticComponent<import("./DropdownMenuContent").DropdownMenuContentProps & {
+        children?: import("react").ReactNode | undefined;
+    } & import("react").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: import("react").ForwardRefExoticComponent<import("./DropdownMenuSubContent").DropdownMenuSubContentProps & {
+        children?: import("react").ReactNode | undefined;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+}
+export { DropdownMenu };

package/dist/types/components/DropdownMenu/DropdownMenuContent.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import * as Menu from '@radix-ui/react-dropdown-menu';
+export 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'];
+};
+export declare const DropdownMenuContent: React.ForwardRefExoticComponent<DropdownMenuContentProps & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/DropdownMenu/DropdownMenuGroup.d.ts

@@ -0,0 +1,12 @@
+type DropdownMenuGroupProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+    /**
+     * Texto que será exibido como nome do grupo.
+     */
+    label: string;
+};
+export declare function DropdownMenuGroup({ children, label, ...rest }: React.PropsWithChildren<DropdownMenuGroupProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/DropdownMenu/DropdownMenuIcon.d.ts

@@ -0,0 +1,14 @@
+import { IconName } from '@freedom/react-icons';
+import React from 'react';
+type DropdownMenuIconProps = {
+    /**
+     * Nome do ícone que será exibido.
+     */
+    icon?: IconName;
+    /**
+     * Ícone customizado especificado pelo usuário.
+     */
+    renderIcon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;
+};
+export declare function DropdownMenuIcon({ icon, renderIcon }: DropdownMenuIconProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/DropdownMenu/DropdownMenuItem.d.ts

@@ -0,0 +1,26 @@
+export 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;
+};
+export declare function DropdownMenuItem({ className, children, stopPropagation, ...rest }: React.PropsWithChildren<DropdownMenuItemProps>): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DropdownMenu/DropdownMenuSeparator.d.ts

@@ -0,0 +1,7 @@
+export type DropdownMenuSeparatorProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+};
+export declare function DropdownMenuSeparator({ className, ...rest }: DropdownMenuSeparatorProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DropdownMenu/DropdownMenuSub.d.ts

@@ -0,0 +1,33 @@
+export 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;
+};
+export declare function DropdownMenuSub({ className, children, asChild, disabled, label, ...rest }: React.PropsWithChildren<DropdownMenuSubProps>): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DropdownMenu/DropdownMenuSubContent.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import * as Menu from '@radix-ui/react-dropdown-menu';
+export 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'];
+};
+export declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<DropdownMenuSubContentProps & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/DropdownMenu/DropdownMenuText.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { Combine } from '../../utils';
+type DropdownMenuTextOwnProps = {
+    /**
+     * className customizada que será aplicado ao componente.
+     */
+    className?: string;
+};
+type DropdownMenuTextProps = Combine<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, DropdownMenuTextOwnProps>;
+export declare function DropdownMenuText({ className, children, ...rest }: DropdownMenuTextProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/DropdownMenu/index.d.ts

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

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

@@ -0,0 +1,34 @@
+import React from 'react';
+type Props = {
+    /**
+     * Especifica componente que será renderizado quando não houver
+     * erro
+     */
+    children?: React.ReactNode;
+    /**
+     * Especifica componente que será renderizado quando houver
+     * erro
+     */
+    fallback?: React.ReactNode;
+    /**
+     * Evento disparado quando houver um erro
+     */
+    onError?: (error: Error, info: any) => void | Promise<void>;
+    /**
+     *
+     */
+    shouldUpdate?: boolean;
+};
+type State = {
+    hasError?: boolean;
+};
+export declare class ErrorBoundary extends React.Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(): {
+        hasError: boolean;
+    };
+    componentDidUpdate(prevProps: Props): void;
+    componentDidCatch(error: Error, info: any): void;
+    render(): string | number | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode>;
+}
+export {};

package/dist/types/components/FileUpload/FileUpload.constants.d.ts

@@ -0,0 +1,16 @@
+import { IconColor, IconName } from '@freedom/react-icons';
+export declare const CSS_PREFIX = "freedom-file-upload";
+export declare const ITEM_ICON_CONFIG: Record<string, {
+    iconName: IconName;
+    iconColor: IconColor;
+}>;
+export type Unit = 'B' | 'KB' | 'MB' | 'GB' | 'TB' | 'PB' | 'EB' | 'ZB' | 'YB';
+export declare const UNITS: Unit[];
+export declare const KB_UNIT_INDEX = 1;
+export declare const ONE_KB_BYTES = 1024;
+export 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"
+}

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

@@ -0,0 +1,73 @@
+import { FILE_ERROR, Unit } from './FileUpload.constants';
+import { UploadedFile } from './useFileUpload';
+export 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;
+};
+export type FileItemProp<T> = {
+    name: string;
+    extension: string;
+    data?: T;
+};
+export type FileItem = {
+    error?: FILE_ERROR;
+    extension: string;
+    file: File;
+    uploaded: boolean;
+    loading: boolean;
+};
+export declare function FileUpload<T>(props: FileUploadProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/FileUpload/FileUpload.helpers.d.ts

@@ -0,0 +1,13 @@
+import type { FileItem, FileItemProp, FileUploadProps } from './FileUpload';
+import type { UploadedFileResponse } from './useUpload';
+export declare function formatFileSize(fileSize: number): string;
+export declare function getFileExtension(fileName: string): string;
+type GetFileListArrayProps<T> = Pick<FileUploadProps<T>, 'maxSize' | 'maxSizeUnity' | 'accept' | 'maxFiles'> & {
+    files: File[];
+    selectedFilesCount: number;
+};
+export declare function getFileListArray<T>({ files, selectedFilesCount, maxFiles, ...rest }: GetFileListArrayProps<T>): FileItem[];
+export declare function getTotalFilesWithError(fileList: FileItem[]): number;
+export declare function getFetchResponseData(response: Response): Promise<any>;
+export declare function transformFilePropToUploadedFile<T>({ name, extension, data, }: FileItemProp<T>): UploadedFileResponse<T>;
+export {};

package/dist/types/components/FileUpload/FileUploadHeader.d.ts

@@ -0,0 +1,8 @@
+import type { FileItem, FileUploadProps } from './FileUpload';
+import { FILE_ERROR } from './FileUpload.constants';
+type FileUploadHeaderProps<T> = Pick<FileUploadProps<T>, 'accept' | 'description' | 'maxSize' | 'maxSizeUnity' | 'title' | 'maxFiles'> & {
+    files: FileItem[];
+    onClearErrors: (errorTypes: FILE_ERROR[]) => void;
+};
+export declare function FileUploadHeader<T>({ files, accept, description, maxSize, maxSizeUnity, title, onClearErrors, maxFiles, }: FileUploadHeaderProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/FileUpload/FileUploadInputArea.d.ts

@@ -0,0 +1,8 @@
+import { PropsWithChildren } from 'react';
+import type { FileUploadProps } from './FileUpload';
+type FileUploadInputAreaProps<T> = Pick<FileUploadProps<T>, 'accept'> & {
+    onFilesChange: (files: FileList) => void;
+    enabledPickFiles: boolean;
+};
+export declare function FileUploadInputArea<T>({ onFilesChange, accept, children, enabledPickFiles, }: PropsWithChildren<FileUploadInputAreaProps<T>>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/FileUpload/FileUploadItem.d.ts

@@ -0,0 +1,8 @@
+import type { FileItem } from './FileUpload';
+type FileUploadItemProps = {
+    file: FileItem;
+    onDelete: (fileName: string) => void;
+    onRetryUpload: (file: FileItem) => void;
+};
+export declare function FileUploadItem({ file, onDelete, onRetryUpload, }: FileUploadItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/FileUpload/FileUploadList.d.ts

@@ -0,0 +1,8 @@
+import type { FileItem } from './FileUpload';
+type FileUploadListProps = {
+    files: FileItem[];
+    onDelete: (fileName: string) => void;
+    onRetryUpload: (fileItem: FileItem) => void;
+};
+export declare function FileUploadList({ files, onDelete, onRetryUpload, }: FileUploadListProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/FileUpload/index.d.ts

@@ -0,0 +1,3 @@
+export { FileUpload } from './FileUpload';
+export type { FileUploadProps, FileItemProp } from './FileUpload';
+export type { UploadedFile } from './useFileUpload';

package/dist/types/components/FileUpload/useFileUpload.d.ts

@@ -0,0 +1,23 @@
+import { PropsWithChildren } from 'react';
+import { FILE_ERROR } from './FileUpload.constants';
+import type { FileItem, FileUploadProps } from './FileUpload';
+import { UploadedFileResponse } from './useUpload';
+type FileUploadContextData = {
+    files: FileItem[];
+    enabledPickFiles: boolean;
+    handleAddFiles: (fileList: FileList) => void;
+    handleDeleteFile: (fileName: string) => void;
+    handleRetryFileUpload: (fileItem: FileItem) => void;
+    handleClearInvalidFiles: (errorTypes: FILE_ERROR[]) => void;
+};
+export type UploadedFile<T> = Omit<UploadedFileResponse<T>, 'file'> & {
+    file: {
+        name: string;
+        extension: string;
+    };
+};
+export declare function useFileUpload(): FileUploadContextData;
+export declare function FileUploadProvider<T>({ children, fileUploadProps, }: PropsWithChildren<{
+    fileUploadProps: FileUploadProps<T>;
+}>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/FileUpload/useUpload.d.ts

@@ -0,0 +1,28 @@
+import type { FileItem } from './FileUpload';
+export 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;
+};
+export declare function useUpload<T>({ url, requestConfig, }: {
+    url: string;
+    requestConfig?: RequestInit;
+}): {
+    handleUpload: (file: FileItem) => Promise<UploadedFileResponse<T>>;
+};

package/dist/types/components/Filter/Filter.constants.d.ts

@@ -0,0 +1 @@
+export declare const SELECT_MULTI_OPTIONS_TO_SHOW = 3;

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

@@ -0,0 +1,67 @@
+import React from 'react';
+export type FilterTag = {
+    label: string;
+    value?: string;
+};
+export 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.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.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;
+};
+export type FilterHandle = {
+    clearField: (key: string) => void;
+    refetch: () => Promise<void>;
+};
+export declare function FilterComponent<T extends Record<string, any>>({ children, onSubmit, onClear, loading, activeFilters: activeFiltersProps, onExpand, showTitle, containerRef, expanded: expandedProp, closeOnSubmit, preserveDefaultValuesOnClear, }: FilterProps<T>, forwardedRef: React.Ref<FilterHandle>): import("react/jsx-runtime").JSX.Element;
+export declare const Filter: (<T extends Record<string, any>>(props: FilterProps<T> & React.RefAttributes<FilterHandle>) => JSX.Element) & {
+    TextInput: typeof import("./Input/TextInput").FilterTextInput;
+    Select: typeof import("./Input/Select").FilterSelect;
+    DatePicker: typeof import("./Input/DatePicker").FilterDatePicker;
+    Switch: typeof import("./Input/Switch").FilterSwitch;
+};

package/dist/types/components/Filter/Filter.helpers.d.ts

@@ -0,0 +1,4 @@
+export declare function extractValue(data: {
+    value: string;
+    label: string;
+} | string | Date | boolean): string;

package/dist/types/components/Filter/FilterTags.d.ts

@@ -0,0 +1,6 @@
+import type { FilterTag } from './Filter';
+type FiltersProps = {
+    activeFilters: FilterTag[];
+};
+export declare function FilterTags({ activeFilters }: FiltersProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/Filter/Input/DatePicker.d.ts

@@ -0,0 +1,7 @@
+import type { DatePickerProps } from '../../DatePicker/DatePicker';
+import { Rules } from './Rules';
+type RequiredTextInputProps = Required<Pick<DatePickerProps, 'name'>>;
+export declare function FilterDatePicker(props: DatePickerProps & RequiredTextInputProps & {
+    rules?: Rules;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/Filter/Input/Rules.d.ts

@@ -0,0 +1,56 @@
+export 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>;
+};
+/**
+ * Esse componente foi criado apenas para ser usado na documentação do storybook
+ * para podermos motrar uma tabela com as propriedades do tipoi `Rules`.
+ */
+export declare function DumpWithRules(props: Rules): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,7 @@
+import type { SelectProps } from '../../Select/Select';
+import { Rules } from './Rules';
+type RequiredTextInputProps = Required<Pick<SelectProps, 'name'>>;
+export declare function FilterSelect(props: SelectProps & RequiredTextInputProps & {
+    rules?: Rules;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/Filter/Input/Switch.d.ts

@@ -0,0 +1,6 @@
+import type { SwitchProps } from '../../Switch/Switch';
+type RequiredSwitchProps = Required<Pick<SwitchProps, 'name'>>;
+export declare function FilterSwitch(props: SwitchProps & RequiredSwitchProps & {
+    compact?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/Filter/Input/TextInput.d.ts

@@ -0,0 +1,7 @@
+import type { TextInputProps } from '../../TextInput/TextInput';
+import { Rules } from './Rules';
+type RequiredTextInputProps = Required<Pick<TextInputProps, 'name'>>;
+export declare function FilterTextInput(props: TextInputProps & RequiredTextInputProps & {
+    rules?: Rules;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import { FilterDatePicker } from './DatePicker';
+import { FilterSelect } from './Select';
+import { FilterSwitch } from './Switch';
+import { FilterTextInput } from './TextInput';
+export declare const Input: {
+    FilterTextInput: typeof FilterTextInput;
+    FilterSelect: typeof FilterSelect;
+    FilterDatePicker: typeof FilterDatePicker;
+    FilterSwitch: typeof FilterSwitch;
+};

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

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