import { type EventEmitter } from '../../stencil-public-runtime';
import { type FormValidationState } from '../../shared/utils/form';
import type { InputActionClickDetail, InputDensity, InputState, InputToggle, InputType, InputValidationChangeDetail, InputValidator } from './input.types';
/**
 * O `br-input` captura dados de texto em linha única, como nomes, e-mails, números ou senhas.
 *
 * Configure `label`, `placeholder` e o tipo em `type` (como `text`, `email`, `password`, `number`). Use `state` (`success`, `danger`, `info`, `warning`) para indicar validação.
 *
 * ```html
 * <br-input label="E-mail" type="email" placeholder="nome@exemplo.com"></br-input>
 * <br-input label="Senha" type="password"></br-input>
 * ```
 *
 * Em formulários HTML, o componente integra-se nativamente via `ElementInternals`, participando do submit e da validação nativa com `required`.
 *
 * ### Quando usar
 *
 * - Entrada de texto curto que cabe em uma única linha (nome, CPF, e-mail, telefone).
 * - Campo de busca ou senha com alternância de visualização.
 *
 * ### Quando evitar
 *
 * - Textos longos ou com quebra de linha: use `br-textarea`.
 * - Escolha entre opções pré-definidas: use `br-select` ou `br-radio`.
 *
 * Consulte as [diretrizes de design do GovBR](https://www.gov.br/ds/components/input?tab=designer).
 *
 * @category Formulários
 * @status stable
 * @slot action - Botão à direita do input.
 * @slot icon - Ícone à esquerda do input.
 * @slot help-text - Personalização do texto de ajuda.
 * @slot feedback - Mensagem de feedback como resposta específica a uma interação do usuário com o input. Pode ser feedback de erro, aviso, sucesso ou informação.
 * @slot validation-loading - Indicador exibido enquanto o validator assíncrono está pendente.
 *
 * @part container - Contêiner visual principal do input.
 * @part label - Rótulo do input.
 * @part input - Elemento input nativo.
 * @part group - Grupo que contém ícone, input, botão e ajuda.
 * @part icon - Contêiner do slot de ícone.
 * @part action - Botão de ação lateral.
 * @part action-button - Botão interno reexportado do br-button da ação.
 * @part clear - Botão de limpar exibido com `clearable` enquanto há texto editável.
 * @part help-text - Texto de ajuda ou slot de ajuda.
 * @part feedback - Slot de feedback.
 */
export declare class Input {
    elementInternals?: ElementInternals;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    formStateRestoreCallback(state: string | File | FormData | null): void;
    /**
     * Referência ao elemento host do componente.
     * Utilize esta propriedade para acessar e manipular o elemento do DOM associado ao componente.
     */
    el: HTMLBrInputElement;
    formDisabled: boolean;
    hasActionSlot: boolean;
    hasFeedbackSlot: boolean;
    hasValidationLoadingSlot: boolean;
    hasIconSlot: boolean;
    internalState?: InputState;
    isValidating: boolean;
    validatorMessage: string | null;
    isPasswordVisible: boolean;
    /**
     * Especifica o tipo de entrada do campo.
     */
    readonly type: InputType;
    /**
     * Controla o comportamento de preenchimento automático do navegador para o input.
     */
    readonly autocomplete?: InputToggle;
    /**
     * Ajusta a densidade, alterando o espaçamento interno para um visual mais compacto ou mais expandido.
     * Aceita `small`, `medium` ou `large`. Valores inválidos usam `medium`.
     */
    readonly density: InputDensity;
    /**
     * Desativa o input, tornando-o não interativo.
     */
    readonly disabled: boolean;
    /**
     * Se verdadeiro, o rótulo e o input estarão na mesma linha (layout inline).
     * @deprecated Use `inline`.
     */
    readonly isInline: boolean;
    /** Exibe rótulo e controle em linha. Quando informada, tem precedência sobre `isInline`. */
    readonly inline?: boolean;
    /**
     * Se verdadeiro, o input terá destaque visual.
     * @deprecated Use `highlight`.
     */
    readonly isHighlight: boolean;
    /** Habilita destaque visual. Quando informada, tem precedência sobre `isHighlight`. */
    readonly highlight?: boolean;
    /**
     * Define o estado do input
     * @remarks
     * O estado é propagado para o slot de feedback, mas também pode ser controlado diretamente pelo conteúdo do slot.
     */
    readonly state?: InputState;
    /** Estado de feedback. Quando informado, tem precedência sobre `state`. */
    readonly feedbackState?: InputState;
    /**
     * Texto exibido como rótulo do input.
     */
    readonly label?: string;
    /** Nome acessível usado quando não há um rótulo visual. */
    readonly ariaLabel: string | null;
    /**
     * Identificador único.
     * Caso não seja fornecido, um ID gerado automaticamente será usado.
     */
    readonly customId: string;
    /**
     * Nome do input, utilizado para identificação em formulários.
     */
    readonly name?: string;
    /**
     * Texto exibido dentro do input quando está vazio, fornecendo uma dica ou sugestão ao usuário.
     */
    readonly placeholder?: string;
    /**
     * Se verdadeiro, o valor do input é exibido, mas não pode ser editado pelo usuário.
     */
    readonly readonly: boolean;
    /**
     * Se verdadeiro, o input é obrigatório e deve ser preenchido antes que o formulário possa ser enviado.
     */
    readonly required: boolean;
    /**
     * Valor exibido no input.
     * Pode ser alterado pelo usuário se a propriedade `readonly` não estiver ativa.
     */
    value?: string;
    /**
     * Largura do campo de entrada (por exemplo, '88px').
     * Quando definido, sobrescreve a largura padrão de 100%.
     */
    readonly controlWidth?: string;
    /**
     * Remove a borda do input quando não está em foco.
     * Útil para composições contextuais (ex.: paginação).
     */
    readonly borderless: boolean;
    /**
     * Texto adicional que fornece ajuda ou informações sobre o input.
     */
    readonly helpText?: string;
    /**
     * Controla a correção automática do texto.
     */
    readonly autocorrect: string;
    /**
     * Define o valor mínimo para campos de entrada numéricos. Deve ser um número finito;
     * valores inválidos são ignorados.
     */
    readonly min?: number;
    /**
     * Define o valor máximo para campos de entrada numéricos. Deve ser um número finito;
     * valores inválidos são ignorados.
     */
    readonly max?: number;
    /**
     * Define o comprimento mínimo do valor do campo de entrada. Deve ser um inteiro não negativo;
     * valores inválidos são ignorados.
     */
    readonly minlength?: number;
    /**
     * Define o comprimento máximo do valor do campo de entrada. Deve ser um inteiro não negativo;
     * valores inválidos são ignorados.
     */
    readonly maxlength?: number;
    /**
     * Se verdadeiro, permite a entrada de múltiplos e-mails (quando type="email").
     */
    readonly multiple: boolean;
    /**
     * Expressão regular usada para validar o valor final, sem alterar o texto digitado.
     * Diferentemente de `mask`, esta prop valida, mas não formata a entrada.
     *
     * @example
     * ```html
     * <br-input label="CPF" pattern="[0-9]{11}"></br-input>
     * ```
     */
    readonly pattern?: string;
    /**
     * Formata o valor durante a digitação; use `#` para marcar posições numéricas.
     * Diferentemente de `pattern`, esta prop não substitui uma regra de validação.
     *
     * @example
     * ```html
     * <br-input label="CPF" mask="###.###.###-##"></br-input>
     * ```
     */
    readonly mask?: string;
    /**
     * Função ou regra de validação customizada para o campo.
     *
     * A função pode ser síncrona ou assíncrona. Retorne uma mensagem para invalidar o
     * campo e `null` ou `''` para validá-lo. A regra é executada no `change` ou pelo
     * método `validate()`, nunca a cada tecla.
     *
     * Em frameworks, passe a função como property binding, por exemplo:
     * `validator={validate}` no React, `[validator]="validate"` no Angular ou
     * `:validator="validate"` no Vue.
     *
     * Como alternativa para HTML sem binding de propriedades, uma string pode
     * referenciar uma função global em `window`. A forma inline legada aceita apenas
     * comparação simples; JavaScript arbitrário é rejeitado para manter CSP segura.
     * Prefira sempre a função por binding.
     *
     * Durante validações assíncronas, o campo sinaliza `aria-busy="true"`, exibe o
     * indicador de carregamento e emite `brInputValidationChange`.
     *
     * @example
     * ```ts
     * input.validator = async (value) => {
     *   if (!value) return 'Campo obrigatório';
     *   const disponivel = await checarDisponibilidade(value);
     *   return disponivel ? null : 'Este valor já está em uso';
     * };
     * ```
     */
    readonly validator?: InputValidator | string;
    /**
     * Define o valor do passo para campos de entrada numéricos. Deve ser um número finito maior que 0;
     * valores inválidos são ignorados.
     */
    readonly step?: number;
    /**
     * Texto exibido no botão de ação à direita do input.
     */
    readonly actionLabel?: string;
    /**
     * Define o tabindex do botão de ação.
     * Útil para remover o botão da sequência de tabulação quando o foco é gerenciado externamente (ex.: br-select).
     * Aceita inteiros maiores ou iguais a -1; valores inválidos são ignorados.
     */
    readonly actionTabIndex?: number;
    /**
     * Exibe um botão para limpar o texto enquanto o campo tem valor e aceita edição.
     * O botão fica à esquerda do botão de ação, quando houver. Ao ser acionado,
     * limpa o valor, emite `input` uma única vez e `brClear`, e devolve o foco ao campo.
     * Não é exibido com `disabled` ou `readonly`.
     * @default false
     */
    readonly clearable: boolean;
    protected handleValueChange(newValue: string): void;
    protected handleMaskChange(): void;
    protected handleStateChange(): void;
    protected handleFeedbackStateChange(): void;
    private updateInternalState;
    /**
     * Valor atualizado do input
     * @deprecated Use o evento nativo `input` e leia `event.target.value`.
     */
    valueChange: EventEmitter<string>;
    /**
     * Emitido quando o usuário aciona o botão de limpar (`clearable`), depois que o
     * valor foi limpo e o evento `input` foi disparado.
     */
    brClear: EventEmitter<void>;
    /**
     * Notifica a ativação do botão do slot `action` por clique ou teclado.
     * Emitido no host com `detail.originalEvent` contendo o clique original.
     * Propaga e atravessa Shadow DOM; não é cancelável nem altera o clique nativo.
     * Não emite para o campo textual, botão de senha, inicialização ou controle desabilitado.
     */
    brInputActionClick: EventEmitter<InputActionClickDetail>;
    /**
     * Informa o início e o resultado do validator, inclusive quando ele consulta
     * um serviço remoto. O `detail` contém `validating`, `valid` e `message`;
     * escrita programática e reset não representam interação do usuário.
     */
    brInputValidationChange: EventEmitter<InputValidationChangeDetail>;
    componentWillLoad(): void;
    componentDidLoad(): void;
    disconnectedCallback(): void;
    componentDidUpdate(): void;
    componentShouldUpdate(newValue: unknown, oldValue: unknown, propName: string): boolean;
    componentDidRender(): void;
    /**
     * Retorna `true` se o valor do input for válido, caso contrário `false`.
     * Se o input for inválido, exibe uma mensagem de erro padrão do navegador.
     */
    reportValidity(): Promise<boolean>;
    /**
     * Define uma mensagem de validação customizada para o input.
     * Se a mensagem for uma string vazia, o erro customizado é limpo.
     *
     * @param message - Mensagem de erro customizada ou string vazia para limpar
     * @example
     * ```typescript
     * const input = document.querySelector('br-input');
     *
     * // Define erro customizado
     * await input.setCustomValidity('CPF inválido');
     *
     * // Limpa o erro
     * await input.setCustomValidity('');
     * ```
     */
    setCustomValidity(message: string): Promise<void>;
    private resolveValidator;
    private runValidator;
    /**
     * Executa a regra customizada e retorna se o campo está válido.
     * Se o validator for assíncrono, aguarda a resposta e ignora resultados
     * antigos quando uma execução posterior já começou.
     */
    validate(): Promise<boolean>;
    /**
     * Retorna `true` se o valor do input for válido, caso contrário `false`.
     * Se o input for inválido, dispara um evento 'invalid'.
     */
    checkValidity(): Promise<boolean>;
    /** Retorna um snapshot serializável da Constraint Validation API. */
    getValidationState(): Promise<FormValidationState>;
    /** Seleciona todo o texto do controle nativo, conforme HTMLInputElement.select(). */
    select(): Promise<void>;
    /** Substitui um intervalo de texto usando a API nativa do input. */
    setRangeText(replacement: string, start?: number, end?: number, selectionMode?: SelectionMode): Promise<void>;
    /** Define o intervalo selecionado no controle nativo. */
    setSelectionRange(start: number, end: number, direction?: 'forward' | 'backward' | 'none'): Promise<void>;
    /** Incrementa o valor numérico pelo step nativo. */
    stepUp(n?: number): Promise<void>;
    /** Decrementa o valor numérico pelo step nativo. */
    stepDown(n?: number): Promise<void>;
    /** Abre o picker nativo quando o navegador e o tipo do input oferecem essa API. */
    showPicker(): Promise<void>;
    private nativeInput?;
    private slotContentObserver?;
    private initialValue;
    private manualValidationMessage;
    private validationRunId;
    private syncProgrammaticValue;
    private updateValidity;
    private normalizeState;
    private get effectiveType();
    private get effectiveAutocomplete();
    private get effectiveState();
    private get effectiveMin();
    private get effectiveMax();
    private get effectiveMinLength();
    private get effectiveMaxLength();
    private get effectiveStep();
    private get effectiveActionTabIndex();
    private syncCssPartAttributes;
    private propagateStateToFeedback;
    /**
     * Retorna um mapa de classes CSS para o input, baseado no estado interno e nas propriedades do componente.
     * @returns Um objeto representando as classes CSS a serem aplicadas ao input.
     */
    private getInputCssClassMap;
    private isDisabled;
    /**
     * Manipula o evento de input, aplicando máscara se necessário e emitindo o valor atualizado.
     * @param event Evento de input do elemento HTMLInputElement
     */
    private readonly handleInput;
    private readonly handleChange;
    /**
     * Renderiza o rótulo do input, considerando se está em modo inline ou não.
     * @returns JSX.Element representando o rótulo do input.
     */
    private readonly renderLabel;
    /**
     * Verifica se um slot específico possui conteúdo.
     * @param slotName Nome do slot a ser verificado
     * @returns true se o slot possui conteúdo, false caso contrário
     */
    private hasSlotContent;
    private syncSlotState;
    private readonly handleSlotChange;
    private syncFormState;
    private nativeValueUpdate;
    /**
     * Reproduz a submissão implícita do `<input>` nativo: o campo interno fica no
     * Shadow DOM e não pertence ao `<form>` do documento. Segue o botão padrão do
     * formulário (o primeiro com `type="submit"`, inclusive `br-button`): se ele
     * estiver desabilitado, não há envio. A submissão ocorre depois do despacho da
     * tecla, para respeitar `preventDefault()` do consumidor e não ativar o elemento
     * que receber o foco durante o envio.
     */
    private handleKeyDown;
    private readonly renderInput;
    /**
     * Renderiza o texto de ajuda do input, considerando se está definido como string ou slot.
     * @returns JSX.Element representando o texto de ajuda.
     */
    private readonly renderHelpText;
    /**
     * Renderiza o ícone de visibilidade da senha, alternando entre mostrar e esconder.
     * @returns JSX.Element representando o ícone de visibilidade da senha.
     */
    private readonly renderIconPassword;
    /**
     * Alterna a visibilidade da senha, mudando o tipo do input entre 'text' e 'password'.
     * @returns void
     */
    private readonly togglePasswordVisibility;
    /**
     * Renderiza o slot de ícone, caso exista.
     * @returns JSX.Element representando o slot de ícone.
     */
    private renderIconSlot;
    private isClearButtonVisible;
    /** Mantém o foco no campo ao clicar no botão de limpar, como o "x" de um campo de busca nativo. */
    private readonly keepInputFocus;
    private readonly handleClearClick;
    /**
     * Renderiza o botão de limpar quando `clearable` está ativo e há texto editável.
     * @returns JSX.Element do botão ou `null`.
     */
    private renderClearButton;
    private handleActionClick;
    /**
     * Renderiza o botão de ação do input, considerando o tipo de input e slots disponíveis.
     * @returns JSX.Element representando o botão de ação.
     */
    private renderButton;
    /**
     * Renderiza o conteúdo do input quando está em linha, considerando se há ícone ou não.
     * @returns JSX.Element representando o conteúdo do input em linha.
     */
    private readonly renderInlineInputContent;
    /**
     * Renderiza o conteúdo do input, considerando se há ícone ou não.
     * @returns JSX.Element representando o conteúdo do input.
     */
    private readonly renderInputContent;
    /**
     * Renderiza o conteúdo do input com ícone, organizando os elementos em um grupo e aplicando estilos de largura quando necessário.
     */
    private readonly renderInputWithIcon;
    /**
     * Renderiza o conteúdo do input sem ícone, organizando os elementos em um grupo.
     * @returns JSX.Element representando o conteúdo do input sem ícone.
     */
    private readonly renderInputWithoutIcon;
    /**
     * Renderiza o slot de feedback, caso exista, permitindo que mensagens de feedback sejam exibidas em resposta a interações do usuário com o input.
     * @returns JSX.Element representando o slot de feedback.
     */
    private renderFeedback;
    private renderValidationLoading;
    /**
     * Aplica a máscara configurada ao valor do input, se houver.
     * @returns void
     */
    private applyMaskToValue;
    /**
     * Aplica a máscara configurada a um valor específico.
     * @param value O valor a ser mascarado.
     * @returns O valor mascarado.
     */
    private applyMask;
    /**
     * Verifica se uma máscara está configurada.
     * @returns boolean indicando se uma máscara está configurada.
     */
    private hasMaskConfigured;
    /**
     * Renderiza o componente de input.
     * @returns JSX.Element representando o componente de input.
     */
    render(): any;
}