@free-dom/react-components 2.0.0

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

@@ -0,0 +1,153 @@
+import { SelectInstance } from 'react-select';
+import { IconName } from '@freedom/react-icons';
+import React from 'react';
+export type SelectOption = {
+    value: unknown;
+    label: string;
+    disabled?: boolean;
+    separator?: boolean;
+    icon?: IconName;
+    iconPosition?: 'left' | 'right';
+};
+export 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;
+};
+export type SelectProps = Pick<React.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.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.FunctionComponent<React.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.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';
+};
+export declare const Select: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<SelectInstance<SelectOption, boolean, SelectGroupOption>>>;
+export {};

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

@@ -0,0 +1,6 @@
+import type { SelectGroupOption, SelectOption, SelectProps } from './Select';
+export declare function getOptionsWithSelectAllOption(options: SelectOption[] | SelectGroupOption[] | undefined): (SelectOption | SelectGroupOption)[];
+export declare function getSelectAllCheckboxStatus(options: SelectOption[], value: SelectOption[]): boolean | 'indeterminate';
+export declare function isSelectGroup(options: SelectProps['options']): boolean;
+export declare function filterEnabledSelectOptions(options: SelectOption[]): SelectOption[];
+export declare function isAllEnabledOptionsSelected(options: SelectOption[], selectValue: SelectOption[]): boolean;

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

@@ -0,0 +1,3 @@
+import type { ContainerProps } from 'react-select';
+import type { SelectGroupOption, SelectOption } from './Select';
+export declare function SelectContainer(props: ContainerProps<SelectOption, boolean, SelectGroupOption>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,3 @@
+import { SingleValueProps } from 'react-select';
+import type { SelectOption, SelectGroupOption } from './Select';
+export declare function SingleValue({ data, }: SingleValueProps<SelectOption, boolean, SelectGroupOption>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,8 @@
+import { IconName } from '@freedom/react-icons';
+type StartAdornmentProps = {
+    icon?: IconName;
+    renderIcon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;
+};
+export declare function InputIcon({ icon, renderIcon }: StartAdornmentProps): import("react/jsx-runtime").JSX.Element;
+export declare function StartAdornment({ icon, renderIcon }: StartAdornmentProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,3 @@
+import type { ValueContainerProps } from 'react-select';
+import type { SelectGroupOption, SelectOption } from './Select';
+export declare function ValueContainer(props: ValueContainerProps<SelectOption, boolean, SelectGroupOption>): import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1,37 @@
+import { Variant } from '../Typography';
+export 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;
+};
+declare function Skeleton({ rows, height, width, inline, style, borderRadius, className, as, }: SkeletonProps): import("react/jsx-runtime").JSX.Element;
+export { Skeleton };

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

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

package/dist/types/components/Stepper/Step.d.ts

@@ -0,0 +1,31 @@
+export 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;
+};
+export declare function StepComponent({ children, }: React.PropsWithChildren<StepProps>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,36 @@
+import React from 'react';
+import { StepComponent } from './Step';
+export type StepperProps = {
+    /**
+     * Recebe o children Step, deve ser passado entre
+     * a tag de abertura e a tag de fechamento.
+     */
+    children: React.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): import("react/jsx-runtime").JSX.Element;
+declare namespace Stepper {
+    var Step: typeof StepComponent;
+}
+export { Stepper };

package/dist/types/components/Stepper/StepperBar.d.ts

@@ -0,0 +1,13 @@
+export type StepButtonProps = {
+    title: string;
+    subtitle?: string;
+    completed?: boolean;
+    current?: boolean;
+    edited?: boolean;
+    disabled?: boolean;
+    currentIndex?: number;
+    active?: boolean;
+    index: number;
+    onIndexChange: (value: number) => void;
+};
+export declare function StepperBar({ title, subtitle, completed, current, active, edited, currentIndex, disabled, index, onIndexChange, }: StepButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Stepper/StepperIcon.d.ts

@@ -0,0 +1,8 @@
+interface StepperIconProps {
+    completed?: boolean;
+    currentIndex?: number;
+    index?: number;
+    disabled?: boolean;
+}
+export declare function StepperIcon({ completed, index, currentIndex, disabled, }: StepperIconProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/Stepper/StepperLabel.d.ts

@@ -0,0 +1,12 @@
+type StepperLabelProps = {
+    title: string;
+    subtitle?: string;
+    index: number;
+    edited?: boolean;
+    currentIndex?: number;
+    completed?: boolean;
+    active?: boolean;
+    disabled?: boolean;
+};
+export declare function StepperLabel({ title, subtitle, edited, active, index, disabled, currentIndex, completed, }: StepperLabelProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,61 @@
+import React from 'react';
+import { IconName } from '@freedom/react-icons';
+export 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;
+};
+export declare const Switch: React.ForwardRefExoticComponent<SwitchProps & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<HTMLButtonElement>>;

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

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

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

@@ -0,0 +1,33 @@
+import React from 'react';
+import { TabsItem } from './TabsItem';
+import { TabsHeader } from './TabsHeader';
+import { TabsContent } from './TabsContent';
+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.RefObject<HTMLDivElement>;
+};
+declare function Tabs({ children, orientation, value, defaultValue, onValueChange, containerRef, }: React.PropsWithChildren<TabsProps>): import("react/jsx-runtime").JSX.Element;
+declare namespace Tabs {
+    var Header: typeof TabsHeader;
+    var Item: typeof TabsItem;
+    var Content: typeof TabsContent;
+}
+export { Tabs };

package/dist/types/components/Tabs/TabsContent.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+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;
+};
+export declare function TabsContent({ children, value, className, }: React.PropsWithChildren<TabsContentProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/Tabs/TabsHeader.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+type TabsHeaderProps = {
+    /**
+     * Conteúdo do Tabs. Deve ser composto por um ou mais dos
+     * componentes: `Tabs.Item`
+     */
+    children: React.ReactNode;
+};
+export declare function TabsHeader({ children }: TabsHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/Tabs/TabsItem.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import { IconName } from '@freedom/react-icons';
+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;
+};
+export declare function TabsItem({ children, value, description, disabled, icon, }: React.PropsWithChildren<TabsItemProps>): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/types/components/Tabs/useTabs.d.ts

@@ -0,0 +1,9 @@
+import React, { PropsWithChildren } from 'react';
+type TabsContextProps = {
+    activeTabValue?: string;
+    orientation?: string;
+    containerRef?: React.RefObject<HTMLDivElement>;
+};
+export declare function TabsProvider({ children, orientation, activeTabValue, containerRef, }: PropsWithChildren<TabsContextProps>): import("react/jsx-runtime").JSX.Element;
+export declare function useTabs(): TabsContextProps;
+export {};

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

@@ -0,0 +1,15 @@
+import { Combine } from '../../utils';
+export type Variant = 'warning' | 'info' | 'success' | 'danger' | 'severe-warning' | 'custom';
+type TagOwnProps = {
+    /**
+     * Especifica o tipo de Tag que será renderizado.
+     */
+    variant: Variant;
+    /**
+     * Classes de estilo passadas para o elemento mais externo do componente.
+     */
+    className?: string;
+};
+export type TagProps = Combine<React.HTMLAttributes<HTMLElement>, TagOwnProps>;
+export declare function Tag({ variant, children, className, ...rest }: TagProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/types/components/TextInput/ClearButton.d.ts

@@ -0,0 +1,9 @@
+type ClearButtonProps = {
+    onClick?: React.MouseEventHandler<HTMLButtonElement>;
+    visible: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    compact?: boolean;
+};
+export declare function ClearButton({ onClick, visible, disabled, readOnly, compact, }: ClearButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/TextInput/EndAdornment.d.ts

@@ -0,0 +1,6 @@
+type EndAdornmentProps = {
+    suffix?: string | JSX.Element;
+    loading?: boolean;
+};
+export declare function EndAdornment({ suffix, loading }: EndAdornmentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/TextInput/InputHelpers.d.ts

@@ -0,0 +1,7 @@
+type InputHelpersProps = {
+    maxLength?: number;
+    textCount?: number;
+    children?: React.ReactNode;
+};
+export declare function InputHelpers({ maxLength, textCount, children, }: InputHelpersProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/TextInput/StartAdornment.d.ts

@@ -0,0 +1,13 @@
+import { IconName } from '@freedom/react-icons';
+type StartAdornmentProps = {
+    prefix?: string;
+    icon?: IconName;
+    renderIcon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;
+};
+export declare function StartAdornment({ icon, renderIcon, prefix, }: StartAdornmentProps): import("react/jsx-runtime").JSX.Element;
+type InputIconProps = {
+    icon?: IconName;
+    renderIcon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;
+};
+export declare function InputIcon({ icon, renderIcon }: InputIconProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1 @@
+export declare const POSITIVE_NUMBERS_THRESHOLD = 0;

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

@@ -0,0 +1,61 @@
+import React from 'react';
+import { IconName } from '@freedom/react-icons';
+import { Mask } from './TextInput.helpers';
+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.FunctionComponent<React.SVGProps<SVGSVGElement>>;
+    /**
+     * Define o estado de loading do input
+     */
+    loading?: boolean;
+};
+export type TextInputProps = React.InputHTMLAttributes<HTMLInputElement> & TextInputOwnProps;
+export declare function TextInputWithForwardedRef({ label, className, hint, renderIcon, icon, prefix, sufix, onChange, defaultValue, compact, mask: maskProps, style, name, value: valueProps, id, error, maxLength, loading, ...rest }: TextInputProps, forwardedRef: React.ForwardedRef<HTMLInputElement>): import("react/jsx-runtime").JSX.Element;
+export declare const TextInput: React.ForwardRefExoticComponent<React.InputHTMLAttributes<HTMLInputElement> & TextInputOwnProps & React.RefAttributes<HTMLInputElement>>;
+export {};

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

@@ -0,0 +1,2 @@
+export type Mask = 'cep' | 'phoneNumber' | 'cpf' | 'cnpj' | 'currency' | 'cpfOrCnpj' | 'number' | 'hour';
+export declare const mask: Record<Mask, (value: string) => string>;

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

@@ -0,0 +1,2 @@
+export { TextInput } from './TextInput';
+export type { Mask } from './TextInput.helpers';

package/dist/types/components/TextToolbar/BackgroundColorSelector.d.ts

@@ -0,0 +1,3 @@
+export declare function BackgroundColorSelector({ enabled, }: {
+    enabled?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/TextToolbar/BubbleDropdown/BubbleDropdown.d.ts

@@ -0,0 +1,8 @@
+import { IconColor, IconName } from '@freedom/react-icons';
+type BubbleDropdownProps = {
+    icon: IconName;
+    children: React.ReactNode;
+    color?: IconColor;
+};
+export declare function BubbleDropdown({ icon, children, color }: BubbleDropdownProps): import("react/jsx-runtime").JSX.Element;
+export {};