import { type EventEmitter } from '../../stencil-public-runtime';
import { type FormValidationState } from '../../shared/utils/form';
import type { InputDensity, InputState, InputToggle, InputType, InputValidationChangeDetail, InputValidator } from './input.types';
/**
 * ## Design System
 *
 * Para a documentação completa de design, incluindo diretrizes de uso, acessibilidade e exemplos visuais, consulte o [Design System do GovBR](https://www.gov.br/ds/components/input?tab=designer).
 *
 * ### Validação e Acessibilidade
 * - **Validação:** Utilize a propriedade `state="danger"` para indicar um campo inválido e forneça o motivo no slot `feedback` utilizando o `<br-message>`. O gerenciamento da regra de validação é de responsabilidade da aplicação ou framework consumidor.
 * - **Acessibilidade:** Este componente respeita a navegação por teclado e automaticamente sinaliza erros para leitores de tela quando `state="danger"` é ativado. Se o campo não possuir rótulo visual (label), use a propriedade `aria-label`.
 *
 * @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 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.
     */
    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 canônico. 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.
     */
    readonly min?: number;
    /**
     * Define o valor máximo para campos de entrada numéricos.
     */
    readonly max?: number;
    /**
     * Define o comprimento mínimo do valor do campo de entrada.
     */
    readonly minlength?: number;
    /**
     * Define o comprimento máximo do valor do campo de entrada.
     */
    readonly maxlength?: number;
    /**
     * Se verdadeiro, permite a entrada de múltiplos e-mails (quando type="email").
     */
    readonly multiple: boolean;
    /**
     * Define o padrão de entrada para validação.
     */
    readonly pattern?: string;
    /**
     * Máscara aplicada ao valor digitado (use `#` para marcar posições numéricas).
     */
    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.
     */
    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).
     */
    readonly actionTabIndex?: number;
    protected handleValueChange(newValue: string): void;
    protected handleMaskChange(): void;
    protected handleStateChange(newState: InputState | undefined): void;
    protected handleFeedbackStateChange(newState: InputState | undefined): void;
    private updateInternalState;
    /**
     * Valor atualizado do input
     * @deprecated Use o evento nativo `input` e leia `event.target.value`.
     */
    valueChange: EventEmitter<string>;
    /** Emitted when the input clear button action is triggered. */
    brClear: EventEmitter<void>;
    /**
     * 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;
    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 initialValue;
    private manualValidationMessage;
    private validationRunId;
    private syncProgrammaticValue;
    private updateValidity;
    private normalizeState;
    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 syncFormState;
    private validityPending;
    private nativeValueUpdate;
    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;
    /**
     * 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;
}