@rdsaude/pulso-react-native-components/dist/index.d.ts

Biblioteca de componentes React Native do Pulso Design System da RD Saúde oferece componentes consistentes e de alto desempenho, alinhados com os padrões da RDSaúde. Ideal para desenvolver aplicações modernas e acessíveis.

import * as react_jsx_runtime from 'react/jsx-runtime';
import * as React$1 from 'react';
import React__default from 'react';
import { Themes, TPulsoTokens } from '@raiadrogasil/pulso-design-tokens';
import * as react_native from 'react-native';
import { PressableProps, TextInputProps, AccessibilityProps, TextProps as TextProps$1, ViewProps, ImageProps, TouchableOpacityProps, View } from 'react-native';
import * as _raiadrogasil_pulso_icons from '@raiadrogasil/pulso-icons';
import { IconName } from '@raiadrogasil/pulso-icons';
import * as _radix_ui_react_context from '@radix-ui/react-context';
import { Scope } from '@radix-ui/react-context';
import { IHandles } from 'react-native-modalize/lib/options';

type TThemeProviderProps = {
    theme: Themes;
    children: React__default.ReactNode;
};
declare function ThemeProvider({ theme, children }: TThemeProviderProps): react_jsx_runtime.JSX.Element;
declare function withThemeProvider<T extends {}>(Component: React__default.ComponentType<T>, variant: Themes): (componentProps: T) => react_jsx_runtime.JSX.Element;

type TButtonVariants = 'brand-primary' | 'neutral-secondary' | 'neutral-tertiary';
type TButtonSizes = 'md' | 'ml' | 'lg' | 'xl';
interface IButtonProps extends PressableProps {
    /**
     * Conteúdo do botão.
     */
    children: React.ReactNode;
    /**
     * Variante do botão (opcional).
     */
    variant?: TButtonVariants;
    /**
     * Tamanho do botão (opcional).
     */
    size?: TButtonSizes;
    /**
     * Indica se o botão deve exibir um estado de carregamento (opcional).
     */
    loading?: boolean;
    /**
     * Indica se o botão está desabilitado.
     */
    disabled?: boolean;
    /**
     * Indica se o botão deve ocupar toda a largura do contêiner (opcional).
     */
    full?: boolean;
}

type TIconSizes = 'tiny' | 'extra-small' | 'small' | 'medium';
type TIconColors = {
    [K in keyof TPulsoTokens as K extends `color${string}` ? K : never]: TPulsoTokens[K];
};
type TIconProps = {
    /**
     * Tamanho do ícone. ("tiny" | "extra-small" | "small" | "medium")
     */
    size?: TIconSizes;
    /**
     * Configura o token da cor do ícone.
     */
    color?: keyof TIconColors;
    /**
     * Nome do ícone que deve ser carregado. O ícone deve estar contido na biblioteca
     * de [ícones do Pulso](https://pulso-react-native.rd.com.br/?path=/story/componentes-icon--lista-de-ícones).
     */
    symbol?: IconName;
    /**
     * Propriedade para identificação do elemento na camada de testes.
     */
    testID?: string;
};
type IconNameMulticolor = 'rdicon-chat-multicolor' | 'rdicon-chat-multicolor-plus' | 'rdicon-basket-multicolor' | 'rdicon-basket-multicolor-plus' | 'rdicon-notification-multicolor' | 'rdicon-notification-multicolor-plus' | 'rdicon-chat-unread-multicolor' | 'rdicon-mail-unread-multicolor';
type IconNameBullet = 'rdicon-bullet-notification-1' | 'rdicon-bullet-notification-2' | 'rdicon-bullet-notification-3' | 'rdicon-bullet-notification-4' | 'rdicon-bullet-notification-5' | 'rdicon-bullet-notification-6' | 'rdicon-bullet-notification-7' | 'rdicon-bullet-notification-8' | 'rdicon-bullet-notification-9' | 'rdicon-bullet-notification-9-plus' | 'rdicon-mail-unread-bullet-notification' | 'rdicon-chat-unread-bullet-notification';
type TIconDualColorsProps = {
    symbols: [IconNameMulticolor, IconNameBullet];
    colors: [keyof TIconColors, keyof TIconColors];
    size?: TIconSizes;
    testID?: string;
};

declare const Icon: {
    ({ size, color, symbol, testID, }: TIconProps): react_jsx_runtime.JSX.Element;
    Dual: (props: TIconDualColorsProps) => react_jsx_runtime.JSX.Element;
};

interface IButtonIconProps extends Pick<TIconProps, 'symbol'> {
    iconColor?: TIconProps["color"];
    testID?: string;
}
declare function ButtonIcon({ iconColor, symbol, testID }: IButtonIconProps): react_jsx_runtime.JSX.Element;

type TButtonLabelProps = {
    children: React.ReactNode;
};
declare function ButtonLabel({ children }: TButtonLabelProps): react_jsx_runtime.JSX.Element;

declare const Button: {
    Root: React__default.ForwardRefExoticComponent<IButtonProps & React__default.RefAttributes<any>>;
    Label: typeof ButtonLabel;
    Icon: typeof ButtonIcon;
};

interface IButtonBadgeProps extends Omit<IButtonProps, 'children'> {
    /**
     * Indica se o botão está desabilitado.
     */
    counter?: number;
}

declare const ButtonBadge: {
    Basket: (props: IButtonBadgeProps) => react_jsx_runtime.JSX.Element;
    Chat: (props: IButtonBadgeProps) => react_jsx_runtime.JSX.Element;
    Notification: (props: IButtonBadgeProps) => react_jsx_runtime.JSX.Element;
};

type TRefreshColors = 'brand' | 'neutral' | 'black' | 'white';
type TRefreshSizes = 'sm' | 'md' | 'lg';
type TRefreshProps = {
    /**
     * Define as opções de cores disponíveis para o componente Refresh.
     */
    color: TRefreshColors;
    /**
     * Define os tamanhos disponíveis para o componente Refresh.
     */
    size: TRefreshSizes;
    /**
     * Propriedade para identificação do elemento na camada de testes.
     */
    testID?: string;
};

declare const Refresh: ({ color, size, testID }: TRefreshProps) => react_jsx_runtime.JSX.Element;

type TCheckboxSizes = 'xl' | 'lg' | 'ml' | 'md';
type TCheckboxProps = {
    /**
     * Conteúdo do Checkbox.
     */
    children?: React.ReactNode;
    /**
     * Método chamado para atualização do estado do Checkbox.
     */
    onPress: () => void;
    /**
     * Define os tamanhos disponíveis para o componente Checkbox.
     */
    size?: TCheckboxSizes;
    /**
     * Propriedade para identificação do elemento na camada de testes.
     */
    testID?: string;
    /**
     * Propriedade para renderização do ícone de checado.
     */
    checked?: boolean;
    /**
     * Propriedade para renderização do ícone de indeterminado.
     */
    indeterminate?: boolean;
    /**
     * Propriedade para exibição de erro.
     */
    error?: boolean;
    /**
     * Propriedade para desabilitar o Checkbox.
     */
    disabled?: boolean;
    /**
     * Define se o Checkbox estará em modo somente leitura.
     */
    readOnly?: boolean;
};

type TCheckboxLabelProps = {
    children: string;
    size?: TCheckboxSizes;
    error?: boolean;
    disabled?: boolean;
    readOnly?: boolean;
    testID?: string;
};
declare function CheckboxLabel({ children, size, error, disabled, readOnly, testID, }: TCheckboxLabelProps): react_jsx_runtime.JSX.Element;

type IHelperTextProps$1 = {
    children: string;
    size?: TCheckboxSizes;
    testID?: string;
};
declare function CheckboxHelperText({ size, testID, ...props }: IHelperTextProps$1): react_jsx_runtime.JSX.Element;

declare const Checkbox: {
    Root: ({ size, checked, indeterminate, onPress, error, disabled, readOnly, children, testID, }: TCheckboxProps) => react_jsx_runtime.JSX.Element;
    Label: typeof CheckboxLabel;
    HelperText: typeof CheckboxHelperText;
    NestedContainer: React__default.ForwardRefExoticComponent<react_native.ViewProps & React__default.RefAttributes<any>>;
};

type ButtonBackProps = Omit<IButtonProps, 'children'> & {
    testID?: string;
};
declare function ButtonBack(props: ButtonBackProps): react_jsx_runtime.JSX.Element;

type ButtonBarCodeProps = Omit<IButtonProps, 'children'> & {
    testID?: string;
};
declare function ButtonBarCode(props: ButtonBarCodeProps): react_jsx_runtime.JSX.Element;

type ButtonMicrophoneProps = Omit<IButtonProps, 'children'> & {
    testID?: string;
};
declare function ButtonMicrophone(props: ButtonMicrophoneProps): react_jsx_runtime.JSX.Element;

type SearchBarSize = 'medium' | 'medium-large' | 'large';
interface ISearchBarProps extends TextInputProps {
    /**
     * Tamanho do SearchBar (opcional).
     */
    size?: SearchBarSize;
    /**
     * Conteúdo do SearchBar.
     */
    children?: React.ReactNode;
    /**
     * Função para limpar o conteúdo.
     */
    onClear?: () => void;
    /**
     * Propriedade para exibir ou não o ícone de busca
     */
    showInternalSearchIcon?: boolean;
    /**
     * Callback de foco no componente
     */
    onFocus?: () => void;
    /**
     *  Callback de retirada de foco do componente
     */
    onBlur?: () => void;
    /**
     *  Propiedade para realizar testes
     */
    testID?: string;
}

declare const SearchBar: {
    Root: (props: ISearchBarProps) => react_jsx_runtime.JSX.Element;
    ButtonBarCode: typeof ButtonBarCode;
    ButtonMicrophone: typeof ButtonMicrophone;
    ButtonBack: typeof ButtonBack;
};

type TRadioSizes = 'xl' | 'lg' | 'ml' | 'md';
type TRadioProps = AccessibilityProps & {
    /**
     * Conteúdo do Radio.
     */
    children?: React.ReactNode;
    /**
     * Método chamado para atualização do estado do Radio.
     */
    onPress: () => void;
    /**
     * Define os tamanhos disponíveis para o componente Radio.
     */
    size?: TRadioSizes;
    /**
     * Propriedade para identificação do elemento na camada de testes.
     */
    testID?: string;
    /**
     * Propriedade para renderização do ícone de checado.
     */
    checked?: boolean;
    /**
     * Propriedade para renderização do ícone de indeterminado.
     */
    indeterminate?: boolean;
    /**
     * Propriedade para exibição de erro.
     */
    error?: boolean;
    /**
     * Propriedade para desabilitar o Radio.
     */
    disabled?: boolean;
    /**
     * Propriedade para habilitar o modo somente leitura.
     */
    readOnly?: boolean;
};

type IHelperTextProps = {
    children: string;
    size?: TRadioSizes;
    testID?: string;
};
declare function RadioHelperText({ size, testID, ...props }: IHelperTextProps): react_jsx_runtime.JSX.Element;

type TRadioLabelProps = {
    children: string;
    size?: TRadioSizes;
    error?: boolean;
    disabled?: boolean;
    readOnly?: boolean;
    testID?: string;
};
declare function RadioLabel({ children, size, error, disabled, readOnly, testID, }: TRadioLabelProps): react_jsx_runtime.JSX.Element;

declare const Radio: {
    Root: ({ size, checked, onPress, error, disabled, readOnly, children, testID, ...props }: TRadioProps) => react_jsx_runtime.JSX.Element;
    Label: typeof RadioLabel;
    HelperText: typeof RadioHelperText;
    NestedContainer: React__default.ForwardRefExoticComponent<react_native.ViewProps & React__default.RefAttributes<any>>;
};

type TLinkSizes = 'md' | 'ml';
interface TLinkProps extends PressableProps {
    /**
     * Tamanho do Componente (opcional).
     */
    size?: TLinkSizes;
    /**
     * Texto do Componente (Obrigatório).
     */
    children: React.ReactNode;
    /**
     * Ícone: exibir ou não o ícone (default: true).
     */
    icon?: boolean;
    /**
     * Indica se o Componente está desabilitado (opcional).
     */
    disabled?: boolean;
    /**
     * Indica se o Componente deve ocupar toda a largura do contêiner (opcional).
     */
    full?: boolean;
}

declare function LinkLabel({ children, size, disabled, }: Partial<TLinkProps>): react_jsx_runtime.JSX.Element;

declare const Link: {
    Root: {
        ({ size, children, icon, disabled, full, ...props }: TLinkProps): react_jsx_runtime.JSX.Element;
        displayName: string;
    };
    Label: typeof LinkLabel;
};

declare function Divider(): react_jsx_runtime.JSX.Element;

type OptionMenuFooterProps = {
    controls: {
        type: 'cancel' | 'confirm';
        label: string;
        handler(): void;
    }[];
    testID?: string;
};
declare function Footer$1({ controls, testID }: OptionMenuFooterProps): react_jsx_runtime.JSX.Element;

type GroupProps = {
    children: React.ReactNode;
    title?: string;
};
declare function Group({ children, title }: GroupProps): react_jsx_runtime.JSX.Element;

interface ItemProps extends Pick<PressableProps, 'onPress' | 'disabled'> {
    type?: 'single' | 'multi';
    content: {
        prefixIcon?: IconName;
        label: string;
        description?: string;
    };
    checked?: boolean;
    testID?: string;
}
declare function Item$1(props: Omit<ItemProps, 'type'>): react_jsx_runtime.JSX.Element;

type ListProps = {
    children: React__default.ReactNode;
    testID?: string;
};
declare function List(props: ListProps): react_jsx_runtime.JSX.Element;

type OptionMenuProps = {
    /**
     * Os componentes filhos a serem renderizados dentro do OptionMenu.
     */
    children?: React.ReactNode;
    /**
     * Especifica o tipo de seleção permitido no OptionMenu. Pode ser "single" ou "multi".
     */
    type?: 'single' | 'multi';
    /**
     * Uma mensagem personalizada a ser exibida quando nenhuma opção estiver disponível.
     */
    customEmptyMessage?: string;
    /**
     * Propriedade para identificar o componente nos testes.
     */
    testID?: string;
    /**
     * Propriedade para setar um tamanho máximo dos itens do OptionMenu.
     */
    maxHeight?: number;
};

declare function Root$1(props: OptionMenuProps): react_jsx_runtime.JSX.Element;
declare namespace Root$1 {
    var displayName: string;
}
declare const OptionMenu: {
    Root: typeof Root$1;
    List: typeof List;
    Item: typeof Item$1;
    Footer: typeof Footer$1;
    Divider: typeof Divider;
    Group: typeof Group;
};

type TTextInputSizes = 'md' | 'ml' | 'lg' | 'xl';
interface IInputTextProps extends TextInputProps {
    /**
     * Tamanho do input (opcional).
     */
    size?: TTextInputSizes;
    /**
     * Indica se o input está desabilitado.
     */
    disabled?: boolean;
    /**
     * Indica se o Input deve ocupar toda a largura do contêiner (opcional).
     */
    full?: boolean;
    /**
     * Indica se o Input é apenas para leitura.
     */
    readonly?: boolean;
    /**
     * Indica se o Input tem erro.
     */
    hasError?: boolean;
    /**
     * Mensagem que será exibida quando houver erro de validação do campo.
     */
    errorText?: string;
    /**
     * Identificador de teste para o componente
     */
    testID?: string;
}

interface IInputTextIconProps extends TIconProps {
}
declare function InputTextIcon({ symbol, testID, ...props }: IInputTextIconProps): react_jsx_runtime.JSX.Element;

declare function InputTextButton({ onPress, testID, ...props }: Omit<IButtonProps, 'children'>): react_jsx_runtime.JSX.Element | null;

declare const InputText: {
    Root: ({ children, size, full, disabled, readonly, hasError, errorText, value, onChangeText, testID, ...props }: IInputTextProps) => react_jsx_runtime.JSX.Element;
    Field: React$1.ForwardRefExoticComponent<IInputTextProps & React$1.RefAttributes<react_native.TextInput>>;
    Label: ({ children }: {
        children: React.ReactNode;
    }) => react_jsx_runtime.JSX.Element;
    Actions: ({ children, }: {
        children: React.ReactNode;
    }) => react_jsx_runtime.JSX.Element;
    Icon: typeof InputTextIcon;
    Button: typeof InputTextButton;
    HelperText: ({ children, withIcon, iconName, }: {
        children: React.ReactNode;
        withIcon?: boolean;
        iconName?: TIconProps["symbol"];
    }) => react_jsx_runtime.JSX.Element | null;
};

type TRatingSizes = 'tiny' | 'small';
interface IRatingProps extends Omit<PressableProps, 'onPress'> {
    /**
     * Tamanho do ícone. ("tiny" | "small" )
     */
    size?: TRatingSizes;
    /**
     * Valor da avaliação.
     */
    value?: number | undefined;
    /**
     * Propriedade para renderizar a quantidade de slots de avaliação.
     */
    ratingLimit?: number;
    /**
     * Função de callback ao pressionar o componente.
     */
    onPress?: (value: number) => void;
}

declare const Rating: ({ size, value, ratingLimit, onPress, ...rest }: IRatingProps) => react_jsx_runtime.JSX.Element;

type ContentProps = {
    /**
     * Os componentes filhos a serem renderizados dentro do Content.
     */
    children?: React.ReactNode;
    /**
     * Especifica o tipo do Content. Pode ser "interactive" ou "title".
     */
    type?: 'interactive' | 'title';
    /**
     * O tamanho do Content. Pode ser 'default' ou 'xs'.
     */
    size?: 'default' | 'xs';
    /**
     * Propriedade para identificar o componente nos testes.
     */
    testID?: string;
};

type ContentActionsProps = ContentProps;
declare function ContentActions(props: ContentActionsProps): react_jsx_runtime.JSX.Element | undefined;

type ContentActionsTextProps = ContentProps;
declare function ContentActionsText(props: ContentActionsTextProps): react_jsx_runtime.JSX.Element;

interface IContentIconProps extends TIconProps {
}
declare function ContentIcon({ testID, symbol, ...props }: IContentIconProps): react_jsx_runtime.JSX.Element;

type IContentLinkProps = TLinkProps;
declare function ContentLink(props: IContentLinkProps): react_jsx_runtime.JSX.Element;

type ContentSubtitleProps = {
    children: React.ReactNode;
    testID?: string;
};
declare function ContentSubtitle(props: ContentSubtitleProps): react_jsx_runtime.JSX.Element;

type ContentTitleProps = {
    children: React.ReactNode;
    testID?: string;
};
declare function ContentTitle(props: ContentTitleProps): react_jsx_runtime.JSX.Element;

type ContentRootProps = ContentProps & PressableProps;
declare function ContentRoot(props: ContentRootProps): react_jsx_runtime.JSX.Element;
declare const Content$2: {
    Root: typeof ContentRoot;
    Icon: typeof ContentIcon;
    ActionsText: typeof ContentActionsText;
    Title: typeof ContentTitle;
    Subtitle: typeof ContentSubtitle;
    Actions: typeof ContentActions;
    Link: typeof ContentLink;
};

type TCardCategoryOrientation = 'vertical' | 'horizontal';
type TCardCategoryProps = {
    /**
     * Orientação do CardCategory.
     */
    orientation?: TCardCategoryOrientation;
    /**
     * Conteúdo do CardCategory.
     */
    children?: React.ReactNode;
    /**
     * Método chamado pressionar o CardCategory.
     */
    onPress: () => void;
    /**
     * Propriedade para identificação do elemento na camada de testes.
     */
    testID?: string;
    /**
     * Propriedade para desabilitar o CardCategory.
     */
    disabled?: boolean;
};

interface CardCategoryIconProps extends TIconProps {
    disabled?: boolean;
    orientation?: TCardCategoryOrientation;
    pressed?: boolean;
}
declare function CardCategoryIcon({ disabled, orientation, symbol, testID, pressed, }: CardCategoryIconProps): react_jsx_runtime.JSX.Element;

type TCardCategoryLabelProps = {
    orientation?: TCardCategoryOrientation;
    children: string;
    disabled?: boolean;
    testID?: string;
};
declare function CardCategoryLabel({ orientation, children, disabled, testID, }: TCardCategoryLabelProps): react_jsx_runtime.JSX.Element;

declare const CardCategory: {
    Root: ({ orientation, onPress, disabled, children, testID, }: TCardCategoryProps) => react_jsx_runtime.JSX.Element;
    Label: typeof CardCategoryLabel;
    Icon: typeof CardCategoryIcon;
};

type TProgressIndicatorSizes = 'tiny' | 'mini' | 'micro' | 'nano';
type TProgressIndicatorVariants = 'brand' | 'neutral' | 'neutral-read-only' | 'inverse' | 'informative' | 'success' | 'warning' | 'danger';
type TProgressIndicatorProps = {
    /**
     * Define os tamanhos disponíveis para o componente ProgressIndicator.
     */
    size?: TProgressIndicatorSizes;
    /**
     * Propriedade para identificação do elemento na camada de testes.
     */
    testID?: string;
    /**
     * Define a porcentagem de preenchimento do componente.
     */
    percentage?: number;
    /**
     * Define a duração (em milissegundos) para a animação de preenchimento de 0% a 100%. Não pode ser usado em conjunto com percentage.
     */
    duration?: number;
    /**
     * Função a ser executada ao completar a animação de preenchimento.
     */
    onComplete?: () => void;
    /**
     * Define se o fundo do componente deve ser transparente ou visível.
     */
    bgTransparent?: boolean;
    /**
     * Define a variação de cor do componente.
     */
    variant?: TProgressIndicatorVariants;
};

declare const ProgressIndicator: ({ size, percentage, duration, onComplete, bgTransparent, variant, testID, }: TProgressIndicatorProps) => react_jsx_runtime.JSX.Element;

/**
 * `InputSelectProps` define as propriedades para o componente Select.
 *
 * @property {React.ReactNode} children - O conteúdo a ser renderizado dentro do Select.
 * @property {'md' | 'ml' | 'lg' | 'xl'} [size] - A variante de tamanho do componente Select.  Defaults to `md`.
 * @property {boolean} [isDisabled] - Indica se o Select está desabilitado.
 * @property {boolean} [isReadOnly] - Indica se o Select está somente leitura.
 * @property {boolean} [isError] - Indica se há um estado de erro para o Select.
 * @property {function} [onSelectionChange] - Função de callback acionada quando a seleção muda.  Recebe o evento como argumento.
 * @property {string} [defaultSelectedValue] - O valor selecionado por padrão.
 * @property {string} [placeholder] - O texto do placeholder a ser exibido quando nenhum valor é selecionado.
 * @property {Array<{ label: string; value: string | number }>} options - Um array de objetos, cada um com as propriedades `label` (string) e `value` (string ou number), representando as opções do select.
 * @property {string} [testID] - Um ID para testes.
 */
type InputSelectProps = {
    children: React.ReactNode;
    size?: 'md' | 'ml' | 'lg' | 'xl';
    orientation?: 'top' | 'bottom';
    maxDropdownHeight?: number;
    isDisabled?: boolean;
    isReadOnly?: boolean;
    isError?: boolean;
    options: {
        label: string;
        value: string | number;
    }[];
    onSelectionChange?<T>(event: T): void;
    onClearSelection?: () => void;
    defaultSelectedValue?: string;
    placeholder?: string;
    testID?: string;
};

type SelectDropdownProps = {
    children: (option: InputSelectProps['options'][0], index: number) => undefined | React.ReactNode;
    testID?: string;
};
declare function SelectDropdownList(props: SelectDropdownProps): react_jsx_runtime.JSX.Element | null;

type SelectFieldProps = {
    children: React.ReactNode;
    testID?: string;
};
declare function SelectField(props: SelectFieldProps): react_jsx_runtime.JSX.Element;

declare const HelperText$1: React$1.ForwardRefExoticComponent<react_native.TextProps & {
    isError?: boolean | undefined;
    isDisabled?: boolean | undefined;
    isReadOnly?: boolean | undefined;
} & React$1.RefAttributes<any>>;

type SelectHelperTextProps = React.ComponentPropsWithoutRef<typeof HelperText$1> & {
    leftIcon?: IconName;
};
declare function SelectHelperText(props: SelectHelperTextProps): react_jsx_runtime.JSX.Element;

type SelectItemProps = React.ComponentProps<typeof OptionMenu.Item> & {
    value: string | number;
    testID?: string;
};
declare function SelectItem(props: SelectItemProps): react_jsx_runtime.JSX.Element;

declare const InputSelect: {
    Root: React__default.ForwardRefExoticComponent<InputSelectProps & React__default.RefAttributes<any>>;
    Field: typeof SelectField;
    Label: React__default.ForwardRefExoticComponent<Omit<react_native.TextProps & {
        isDisabled?: boolean | undefined;
        isReadOnly?: boolean | undefined;
        size?: "md" | "ml" | "lg" | "xl" | undefined;
    } & React__default.RefAttributes<any>, "ref"> & React__default.RefAttributes<any>>;
    Trigger: React__default.ForwardRefExoticComponent<Pick<Omit<Omit<react_native.PressableProps & React$1.RefAttributes<react_native.View> & {
        size?: "md" | "ml" | "lg" | "xl" | undefined;
        isFocused?: boolean | undefined;
        isFilled?: boolean | undefined;
        isDisabled?: boolean | undefined;
        isReadOnly?: boolean | undefined;
        isError?: boolean | undefined;
    }, "ref"> & React__default.RefAttributes<any>, "ref">, "children"> & {
        leftIcon?: TIconProps["symbol"];
        testID?: string;
    } & React__default.RefAttributes<any>>;
    Value: React__default.ForwardRefExoticComponent<{
        testID?: string;
    } & React__default.RefAttributes<any>>;
    HelperText: typeof SelectHelperText;
    DropdownList: typeof SelectDropdownList;
    Item: typeof SelectItem;
};

type SwitchLabelProps = {
    children: string;
    disabled?: boolean;
    testID?: string;
};
declare function SwitchLabel({ children, disabled, testID }: SwitchLabelProps): react_jsx_runtime.JSX.Element;

declare function SwitchRefresh({ testID }: {
    testID?: string;
}): react_jsx_runtime.JSX.Element;

type TSwitchProps = PressableProps & {
    /**
     * valor de ON/OFF do componente Switch.
     */
    value: boolean;
    /**
     * Conteúdo do Switch.
     */
    children?: React.ReactNode;
    /**
     * Método chamado pressionar o Switch.
     */
    onPress?: () => void;
    /**
     * Propriedade para identificação do elemento na camada de testes.
     */
    testID?: string;
    /**
     * Propriedade para desabilitar o Switch.
     */
    disabled?: boolean;
};

declare const Switch: {
    Root: ({ onPress, disabled, value, children, testID, }: TSwitchProps) => react_jsx_runtime.JSX.Element;
    Label: typeof SwitchLabel;
    Refresh: typeof SwitchRefresh;
};

interface TScrimProps {
    /**
     * Conteúdo do Scrim.
     */
    children?: React.JSX.Element | null;
    /**
     * Utilizado na camada de testes
     */
    testID?: string;
}

declare const Scrim: {
    Root: ({ children, testID }: TScrimProps) => react_jsx_runtime.JSX.Element;
};

type SnackbarTypes = 'brand-accent' | 'info' | 'success' | 'warning' | 'danger';
type SnackbarBaseProps = {
    /**
     * Os componentes filhos a serem renderizados dentro do Snackbar.
     */
    children?: React.ReactNode;
    /**
     * Define se o Snackbar deve utilizar 100% da largura disponível.
     */
    full?: boolean;
    /**
     * Propriedade para identificar o componente nos testes.
     */
    testID?: string;
    /**
     * Define as cores e o ícone do Snackbar.
     */
    type?: SnackbarTypes;
    /**
     * Tempo em milissegundos de duração da exibição e animação do Snackbar.
     */
    duration?: number;
    /**
     * Define qual será o texto do botão do Snackbar.Footer.
     */
    buttonLabel?: string;
};
type SnackbarWithLayout = SnackbarBaseProps & {
    /**
     * Define se haverá botões no Snackbar.Footer e qual é o tipo de botão.
     */
    layout: 'with-button' | 'with-link';
    /**
     * Função que será executada quando o botão do Snackbar.Footer for pressionado. Deve ser obrigatório se houver valor para layout.
     */
    onPressFooterButton: () => void;
    /**
     * Define se o Snackbar deve exibir um ícone.
     */
    withIcon?: boolean;
};
type SnackbarWithoutLayout = SnackbarBaseProps & {
    /**
     * Define se haverá botões no Snackbar.Footer e qual é o tipo de botão.
     */
    layout?: never;
    /**
     * Função que será executada quando o botão do Snackbar.Footer for pressionado. Deve ser obrigatório se houver valor para layout.
     */
    onPressFooterButton?: () => void;
    /**
     * Define se o Snackbar deve exibir um ícone.
     */
    withIcon?: boolean;
};
type SnackbarProps = SnackbarWithLayout | SnackbarWithoutLayout;
type SnackbarContentBaseProps = {
    /**
     * Propriedade para identificar o componente nos testes.
     */
    testID?: string;
    /**
     * Define as cores e o ícone do Snackbar.
     */
    type?: SnackbarTypes;
    /**
     * Título do Snackbar.
     */
    title?: string;
    /**
     * Descrição do Snackbar.
     */
    description: string;
    /**
     * Exibe um botão de fechar o Snackbar quando seu valor for verdadeiro.
     */
    closable?: boolean;
    /**
     * Função que será executada quando o usuário clicar no Snackbar.
     */
    onPressRightButton?: () => void;
    /**
     * Define o número máximo de linhas que a descrição pode ter.
     */
    numberOfLines?: 1 | 2;
};
type SnackbarContentWithIcon = SnackbarContentBaseProps & {
    /**
     * Nome do ícone que será exibido ao lado do título.
     */
    iconName: IconName;
    /**
     * Define se o Snackbar deve exibir um ícone.
     */
    withIcon: true;
};
type SnackbarContentWithoutIcon = SnackbarContentBaseProps & {
    /**
     * Nome do ícone que será exibido ao lado do título.
     */
    iconName?: IconName;
    /**
     * Define se o Snackbar deve exibir um ícone.
     */
    withIcon?: false;
};
type SnackbarContentProps = SnackbarContentWithIcon | SnackbarContentWithoutIcon;

declare function Content$1(props: SnackbarContentProps): react_jsx_runtime.JSX.Element;

type FooterProps = {
    testID?: string;
};
declare function Footer(props: FooterProps): react_jsx_runtime.JSX.Element;

type TimerBarProps = {
    testID?: string;
};
declare function TimerBar(props: TimerBarProps): react_jsx_runtime.JSX.Element;

declare function Root(props: SnackbarProps): react_jsx_runtime.JSX.Element;
declare namespace Root {
    var displayName: string;
}
declare const Snackbar: {
    Root: typeof Root;
    TimerBar: typeof TimerBar;
    Content: typeof Content$1;
    Footer: typeof Footer;
};

type BaseProps = {
    testID?: string;
    variants: 'neutral' | 'positive' | 'informative' | 'warning' | 'negative';
};
type HighlightProps = {
    type: 'highlight';
    iconName: TIconProps['symbol'];
};
type IconProps = {
    type: 'icon';
    iconName: TIconProps['symbol'];
};
type TextProps = {
    type: 'text';
    iconName?: never;
};
type CardInformativeProps = (HighlightProps | IconProps | TextProps) & BaseProps;

type CardInformativeRootProps = CardInformativeProps & {
    children: React.ReactNode;
};
declare const CardInformative: {
    Root: (props: CardInformativeRootProps) => react_jsx_runtime.JSX.Element;
    Content: (props: {
        children: React.ReactNode;
        testID?: string;
    }) => react_jsx_runtime.JSX.Element;
    Title: (props: {
        children: React.ReactNode;
        testID?: string;
    }) => react_jsx_runtime.JSX.Element;
    Description: (props: {
        children: React.ReactNode;
        testID?: string;
    }) => react_jsx_runtime.JSX.Element;
};

type FilterSize = 'md' | 'ml';
type InputSize = 'sm' | 'md';
type componentType = 'input' | 'singleFilter';
interface ISingleFilterProps extends Omit<PressableProps, 'disabled'> {
    /**
     * Tamanho do SingleFilter (opcional).
     */
    size?: FilterSize;
    /**
     * seleção do item (opcional).
     */
    selected?: boolean;
    /**
     * seleção do item (opcional).
     */
    checked?: boolean;
    /**
     * desabilita a interação (opcional).
     */
    readOnly?: boolean;
    /**
     * Desabilita componente: ReactNode
     */
    disabled?: boolean;
    /**
     * Componente filho ILabelProps
     */
    children: React.ReactElement<ILabelProps>;
}
interface ILabelProps extends TextProps$1 {
    /**
     * desabilita a interação (opcional).
     */
    readOnly?: boolean;
    /**
     * Desabilita componente: ReactNode
     */
    disabled?: boolean;
    /**
     * seleção do item (opcional).
     */
    selected?: boolean;
    /**
     * tipo do componente.
     */
    type?: componentType;
    /**
     * Componente filho único: ReactElement
     */
    children: string;
}
interface IInputProps extends PressableProps {
    /**
     * Tamanho do SingleFilter (opcional).
     */
    size?: InputSize;
    /**
     * desabilita a interação (opcional).
     */
    readOnly?: boolean;
    /**
     * Componente filho único: ReactElement
     */
    children: React.ReactElement<ILabelProps>;
    /**
     * Oculta o botão de limpar (opcional).
     */
    hiddenClearButton?: boolean;
}
interface IMultiFilterProps extends PressableProps {
    /**
     * Tamanho do SingleFilter (opcional).
     */
    size?: FilterSize;
    /**
     * seleção do item (opcional).
     */
    checked?: boolean;
    /**
     * seleção do item (opcional).
     */
    selected?: boolean;
    /**
     * Desabilita componente: ReactNode
     */
    disabled?: boolean;
    /**
     * Componente filho: ReactNode
     */
    children: React.ReactNode;
    /**
     * desabilita a interação (opcional).
     */
    readOnly?: boolean;
    /**
     * Altera o ícone a ser exibido.
     */
    prefixIcon?: TIconProps['symbol'];
    /**
     * Exibir label quando ativado o padrão true (opcional).
     */
    visibleLabel?: boolean;
}
interface IBadgeProps extends ViewProps {
    /**
     * Tamanho do badage.
     */
    size?: FilterSize;
    /**
     * Componente filho: ReactNode
     */
    children: string;
    /**
     * Desabilita componente: ReactNode
     */
    disabled?: boolean;
    /**
     * desabilita a interação (opcional).
     */
    readOnly?: boolean;
}

declare function Input(props: IInputProps): react_jsx_runtime.JSX.Element;

declare function MultiFilter(props: IMultiFilterProps): react_jsx_runtime.JSX.Element;

declare function SingleFilter(props: ISingleFilterProps): react_jsx_runtime.JSX.Element;

declare function Label({ children, ...rest }: ILabelProps): react_jsx_runtime.JSX.Element;

declare function Badge({ children, size, disabled, readOnly, ...rest }: IBadgeProps): react_jsx_runtime.JSX.Element;

declare const Chip: {
    SingleFilter: typeof SingleFilter;
    MultiFilter: typeof MultiFilter;
    Input: typeof Input;
    Label: typeof Label;
    Badge: typeof Badge;
};

type THelperText = {
    withIcon?: boolean;
    children: React.ReactNode;
    iconSize?: TIconProps['size'];
    iconName?: TIconProps['symbol'];
    hasError?: boolean;
    disabled?: boolean;
    readonly?: boolean;
    testID?: string;
};
declare function HelperText({ children, withIcon, hasError, disabled, readonly, iconSize, iconName, testID, }: THelperText): react_jsx_runtime.JSX.Element;

type TagVariants = 'average' | 'strong' | 'weak' | 'on-sale' | 'principal' | 'secondary' | 'clube-raia' | 'clube-drogasil' | 'assinatura' | 'medicamento-de-geladeira' | 'receita-obrigatoria' | 'generico' | 'referencia' | 'similar' | 'ganhe-stix' | 'trocar-stix' | 'patrocinado';
type TTagProps = {
    /**
     * Conteúdo do componente Tag.
     */
    children?: React.ReactNode;
    /**
     * Propriedade para identificação do elemento na camada de testes.
     */
    testID?: string;
    /**
     * Propriedade utlizada para renderizar os diferentes tipos de Tag.
     */
    variant: TagVariants;
};

declare function TagIcon({ symbol, testID, variant, }: {
    symbol?: TIconProps['symbol'];
    variant?: TagVariants;
    testID?: string;
}): react_jsx_runtime.JSX.Element;

type TTagLabelProps = {
    children: string;
    testID?: string;
    variant?: TagVariants;
};
declare function TagLabel({ children, testID, variant }: TTagLabelProps): react_jsx_runtime.JSX.Element;

declare const Tag: {
    Root: ({ children, testID, variant }: TTagProps) => react_jsx_runtime.JSX.Element;
    Label: typeof TagLabel;
    Icon: typeof TagIcon;
};

type TContentProps = {
    children: React.ReactNode;
    index?: number;
};
declare function Content(props: TContentProps): react_jsx_runtime.JSX.Element | null;

type THeaderProps = {
    title: string;
    index?: number;
};
declare function Header(props: THeaderProps): react_jsx_runtime.JSX.Element;

type TItemProps = {
    children: React__default.ReactNode;
    index?: number;
    defaultExpanded?: boolean;
};
declare function Item(props: TItemProps): react_jsx_runtime.JSX.Element;
declare namespace Item {
    var displayName: string;
}

type TAccordionProps = {
    /**
     * Conteúdo do Accordion.
     */
    children?: React.ReactNode;
    /**
     * Propriedade para identificação do elemento na camada de testes.
     */
    testID?: string;
    /**
     * Propriedade para dizer se o componente está ou não habilitado.
     */
    disabled?: boolean;
};

declare const Accordion: {
    Root: (props: TAccordionProps) => react_jsx_runtime.JSX.Element;
    Content: typeof Content;
    Header: typeof Header;
    Item: typeof Item;
};

type TModalBodyProps = {
    children: React.ReactNode;
    testID?: string;
};
declare function ModalBody({ children, testID }: TModalBodyProps): react_jsx_runtime.JSX.Element;

interface ModalClosableButtonProps extends AccessibilityProps {
    onPress?: () => void;
    testID?: string;
}
declare function ModalClosableButton({ onPress, testID, }: ModalClosableButtonProps): react_jsx_runtime.JSX.Element;

interface TModalDescriptionProps extends AccessibilityProps {
    children: string;
    testID?: string;
}
declare function ModalDescription({ children, testID }: TModalDescriptionProps): react_jsx_runtime.JSX.Element;

type TModalFooterProps = {
    children: React__default.ReactNode;
    testID?: string;
};
interface TButtonFooterProps extends AccessibilityProps {
    onPress?: () => void;
    children: string;
    testID?: string;
}
declare function ModalFirstButtonFooter({ onPress, children, testID, }: TButtonFooterProps): react_jsx_runtime.JSX.Element;
declare function ModalSecondButtonFooter({ onPress, children, testID, }: TButtonFooterProps): react_jsx_runtime.JSX.Element;
declare function ModalFooter({ children, testID }: TModalFooterProps): react_jsx_runtime.JSX.Element;

interface TModalIconProps extends AccessibilityProps {
    symbol?: TIconProps['symbol'];
    testID?: string;
    color?: TIconProps['color'];
}
declare function ModalIcon({ symbol, testID, color }: TModalIconProps): react_jsx_runtime.JSX.Element;

interface THeaderLabelProps extends AccessibilityProps {
    children: string;
    testID?: string;
}
declare function ModalTitle({ children, testID }: THeaderLabelProps): react_jsx_runtime.JSX.Element;

type ModalVariants = 'small' | 'medium';
type TModalProps = {
    /**
     * Controla a exibição do modal
     */
    visible?: boolean;
    /**
     * Conteúdo do componente Modal.
     */
    children?: React.ReactNode;
    /**
     * Propriedade para identificação do elemento na camada de testes.
     */
    testID?: string;
    /**
     * Propriedade utlizada para renderizar o Modal em diferentes larguras.
     */
    variant: ModalVariants;
};

declare const Modal: {
    Root: ({ children, testID, variant, visible, }: TModalProps) => react_jsx_runtime.JSX.Element | null;
    HeaderIcon: typeof ModalIcon;
    HeaderTitle: typeof ModalTitle;
    HeaderClosableButton: typeof ModalClosableButton;
    Description: typeof ModalDescription;
    Body: typeof ModalBody;
    Footer: typeof ModalFooter;
    PrimaryButton: typeof ModalFirstButtonFooter;
    SecondaryButton: typeof ModalSecondButtonFooter;
};

type ToastProps = {
    type: 'neutral' | 'informative' | 'success' | 'warning' | 'danger';
};

declare const Toast: {
    Root: React__default.ForwardRefExoticComponent<ToastProps & ViewProps & {
        children: React__default.ReactNode;
    } & React__default.RefAttributes<any>>;
    Description: (props: {
        children: React__default.ReactNode;
        testID?: string;
    }) => react_jsx_runtime.JSX.Element;
    Icon: (props: TIconProps & {
        testID?: string;
    }) => react_jsx_runtime.JSX.Element;
};

type InputMultiSelectProps = TextInputProps & {
    children: React.ReactNode;
    /** Tamanho do componente de multi-seleção de entrada
     * @default 'ml'
     */
    size?: 'md' | 'ml' | 'lg' | 'xl';
    /** Se a entrada está em um estado de erro
     * @default false
     */
    isError?: boolean;
    /** Se a entrada deve ocupar toda a largura do seu container
     * @default false
     */
    full?: boolean;
    /** Se a entrada está desabilitada
     * @default false
     */
    isDisabled?: boolean;
    /** Se a entrada é somente leitura
     * @default false
     */
    isReadOnly?: boolean;
    /**
     * Array de opções para a entrada de multi-seleção
     * Cada opção tem um id, um label e uma descrição opcional
     */
    options: {
        id: string | number;
        label: string;
        description?: string;
        value?: string;
    }[];
    /**
     * Função de callback que é chamada quando a seleção de opções muda
     * @param options - A nova seleção de opções
     */
    onSelectionChange?(options: InputMultiSelectProps['options']): void;
    /**
     * Identificador de teste para o componente
     */
    testID?: string;
};

declare const InputMultiSelect: {
    Root: React$1.ForwardRefExoticComponent<react_native.TextInputProps & {
        children: React.ReactNode;
        size?: "md" | "ml" | "lg" | "xl";
        isError?: boolean;
        full?: boolean;
        isDisabled?: boolean;
        isReadOnly?: boolean;
        options: {
            id: string | number;
            label: string;
            description?: string;
            value?: string;
        }[];
        onSelectionChange?(options: InputMultiSelectProps["options"]): void;
        testID?: string;
    } & React$1.RefAttributes<any>>;
    Label: React$1.ForwardRefExoticComponent<{
        children: React.ReactNode;
        testID?: string;
    } & React$1.RefAttributes<any>>;
    HelperText: React$1.FC<{
        withIcon?: boolean;
        children: React.ReactNode;
        iconSize?: TIconProps["size"];
        iconName?: TIconProps["symbol"];
        hasError?: boolean;
        disabled?: boolean;
        readonly?: boolean;
        testID?: string;
    }>;
    Control: React$1.FC<{
        leftIcon?: TIconProps["symbol"];
        testID?: string;
    }>;
    DropdownList: React$1.FC<{
        onConfirm?(): void;
        onCancel?(): void;
        testID?: string;
    }>;
};

type TInputPasswordSizes = 'md' | 'ml' | 'lg' | 'xl';
interface IInputPasswordProps extends TextInputProps {
    /**
     * Tamanho do input (opcional).
     */
    size?: TInputPasswordSizes;
    /**
     * Indica se o input está desabilitado.
     */
    disabled?: boolean;
    /**
     * Indica se o Input deve ocupar toda a largura do contêiner (opcional).
     */
    full?: boolean;
    /**
     * Indica se o Input é apenas para leitura.
     */
    readonly?: boolean;
    /**
     * Indica se o Input tem erro.
     */
    hasError?: boolean;
    /**
     * Mensagem que será exibida quando houver erro de validação do campo.
     */
    errorText?: string;
    /**
     * Identificador de teste para o componente
     */
    testID?: string;
}
type InputPasswordTagType = 'AVERAGE' | 'STRONG' | 'WEAK';
interface InputPasswordTagProps extends Omit<TTagProps, 'variant'> {
    variant?: InputPasswordTagType;
    active?: boolean;
}

declare function InputPasswordButton({ onPress, testID, ...props }: Omit<IButtonProps, 'children'>): react_jsx_runtime.JSX.Element | null;

declare const InputPassword: {
    Root: ({ children, size, full, disabled, readonly, hasError, errorText, value, onChangeText, testID, ...props }: IInputPasswordProps) => react_jsx_runtime.JSX.Element;
    Field: React$1.ForwardRefExoticComponent<IInputPasswordProps & React$1.RefAttributes<react_native.TextInput>>;
    Label: ({ children, }: {
        children: React.ReactNode;
    }) => react_jsx_runtime.JSX.Element;
    Actions: ({ children, }: {
        children: React.ReactNode;
    }) => react_jsx_runtime.JSX.Element;
    Icon: ({ symbol, testID, ...props }: TIconProps) => react_jsx_runtime.JSX.Element;
    Button: typeof InputPasswordButton;
    HelperText: ({ children, withIcon, iconName, }: {
        children: React.ReactNode;
        withIcon?: boolean;
        iconName?: TIconProps["symbol"];
    }) => react_jsx_runtime.JSX.Element | null;
    Tag: ({ active, variant, testID, }: InputPasswordTagProps) => react_jsx_runtime.JSX.Element | null;
};

interface TCardShapeProps extends AccessibilityProps {
    /**
     * Conteúdo do componente CardShape.
     */
    children?: React.ReactNode;
    /**
     * Propriedade para identificação do elemento na camada de testes.
     */
    testID?: string;
    /**
     * Propriedade de estado para desabilitar o componente CardShape.
     */
    disabled?: boolean;
    /**
     * Método para pressionar o componente CardShape.
     */
    onPress?: () => void;
    /**
     * Propriedade utilizada para selecionar o componente CardShape
     */
    selected?: boolean;
}

declare const CardShape: {
    Root: ({ children, testID, disabled, onPress, selected, ...rest }: TCardShapeProps) => react_jsx_runtime.JSX.Element;
};

type TInputCounterSizes = 'xl' | 'lg' | 'ml' | 'md';
interface TInputCounterProps extends AccessibilityProps {
    /**
     * Conteúdo do componente InputCounter.
     */
    children?: React.ReactNode;
    /**
     * Propriedade para identificação do elemento na camada de testes.
     */
    testID?: string;
    /**
     * Propriedade de estado para desabilitar o componente InputCounter.
     */
    disabled?: boolean;
    /**
     * Propriedade de estado para controlar tamanho do InputCounter.
     */
    size: TInputCounterSizes;
    /**
     * Propriedade de estado para controlar estado de erro.
     */
    hasError?: boolean;
    /**
     * Mensagem que será exibida quando houver erro de validação do campo.
     */
    errorText: string;
    /**
     * Propriedade de estado para estado readOnly.
     */
    readonly?: boolean;
    /**
     * Propriedade para controlar o valor interno do InputCounter.
     */
    value: number;
    /**
     * Propriedade para setar o estado do valor interno do InputCounter.
     */
    onChange: (value: number) => void;
}

declare const InputCounter: {
    Root: ({ children, testID, disabled, size, hasError, errorText, readonly, value, onChange, }: TInputCounterProps) => react_jsx_runtime.JSX.Element;
    Label: ({ children }: {
        children: React__default.ReactNode;
    }) => react_jsx_runtime.JSX.Element;
    HelperText: ({ children, withIcon, iconName, }: {
        children: React__default.ReactNode;
        withIcon?: boolean;
        iconName?: TIconProps["symbol"];
    }) => react_jsx_runtime.JSX.Element | null;
    MinusButton: (props: Omit<IButtonProps, "variant" | "size" | "children"> & {
        symbol?: _raiadrogasil_pulso_icons.IconName;
    }) => react_jsx_runtime.JSX.Element;
    PlusButton: (props: Omit<IButtonProps, "variant" | "size" | "children"> & {
        symbol?: _raiadrogasil_pulso_icons.IconName;
    }) => react_jsx_runtime.JSX.Element;
};

interface IBottomNavigationContainerProps extends ViewProps {
    /**
     * Conteúdo.
     */
    children: React.ReactNode;
}
interface IBottomNavigationItemProps extends PressableProps {
    /**
     * Propriedade navigation.
     */
    key?: string; /**
     * Propriedade alias.
     */
    alias?: string;
    /**
     * Propriedade para ordenação do item.
     */
    index?: number;
    /**
     * Propriedade para desabilitar o item.
     */
    disabled?: boolean;
    /**
     * propriedade para infomrar o estado ativo.
     */
    isActive?: boolean;
    /**
     * propriedade para infomrar o estado Focus.
     */
    isFocused?: boolean;
    /**
     * Propriedade para indicar o ícone.
     */
    icon?: TIconProps['symbol'];
    /**
     * Propriedade para indicar o ícone ativo.
     */
    iconActive?: TIconProps['symbol'];
    /**
     * Propriedade para indicar o label.
     */
    label?: string;
    /**
     * Propriedade para indicar o label de acessibilidade.
     */
    tabBarAccessibilityLabel?: string;
    /**
     *  Propiedade para realizar testes
     */
    testID?: string;
    /**
     *  Action ao precionar com long press
     */
    onLongPress?: () => void;
    /**
     *  Action ao precionar
     */
    onPress?: () => void;
}

declare function BottomNavigationItem({ key, disabled, isActive, icon, iconActive, label, testID, isFocused, accessibilityLabel, onPress, onLongPress, ...props }: IBottomNavigationItemProps): react_jsx_runtime.JSX.Element;

declare const BottomNavigation: {
    Root: {
        ({ children, }: IBottomNavigationContainerProps): react_jsx_runtime.JSX.Element;
        displayName: string;
    };
    Item: typeof BottomNavigationItem;
};

type StepRange = 1 | 2 | 3 | 4 | 5 | 6 | 7;
interface TStepperProps extends AccessibilityProps {
    /**
     * Propriedade para identificação do elemento na camada de testes.
     */
    testID?: string;
    /**
     * Número total de etapas, aceita valores de 1 a 7.
     */
    steps: StepRange;
    /**
     * Número de etapas concluídas, aceita valores de 1 até o valor definido em steps.
     */
    completed: StepRange;
}

declare const Stepper: ({ testID, steps, completed, ...rest }: TStepperProps) => react_jsx_runtime.JSX.Element | null;

type LogoProps = {
    type: 'white' | 'black' | 'colored' | 'yellow' | 'light-green' | 'dark-green' | 'light-orange' | 'dark-orange' | 'light-blue' | 'dark-blue';
    size: 'large' | 'huge' | 'enormous';
};

declare const Logo: {
    RDSaude: (props: LogoProps) => react_jsx_runtime.JSX.Element;
    Pulso: (props: LogoProps & {
        onlySymbol?: boolean;
    }) => react_jsx_runtime.JSX.Element;
    Raia: (props: LogoProps & {
        onlySymbol?: boolean;
    }) => react_jsx_runtime.JSX.Element;
    Drogasil: (props: LogoProps & {
        onlySymbol?: boolean;
    }) => react_jsx_runtime.JSX.Element;
    RDSaudeTagline: (props: LogoProps) => react_jsx_runtime.JSX.Element;
    Univers: (props: LogoProps & {
        onlySymbol?: boolean;
    }) => react_jsx_runtime.JSX.Element;
};

type ListItemProps = {
    /**
     * Define se o item da lista está desabilitado.
     */
    disabled?: boolean;
    /**
     * Controla a exibição da linha divisória abaixo do item da lista.
     */
    enabledLine?: boolean;
};

type ListItemRootProps = ListItemProps & PressableProps & {
    children: React.ReactNode;
    testID?: string;
};
declare const ListItem: {
    Root: (props: ListItemRootProps) => react_jsx_runtime.JSX.Element;
    Title: (props: {
        children: string;
        testID?: string;
    }) => react_jsx_runtime.JSX.Element;
    Description: (props: {
        children: string;
        testID?: string;
    }) => react_jsx_runtime.JSX.Element;
    Header: (props: ListItemProps & {
        children: React.ReactNode;
        testID?: string;
    }) => react_jsx_runtime.JSX.Element;
    Tag: (props: Omit<TTagProps, "variant"> & {
        variant: "principal" | "secondary";
        testID?: string;
    }) => react_jsx_runtime.JSX.