import { OnInit } from '@angular/core';
import { ControlValueAccessor, FormControl, FormGroup } from '@angular/forms';
import * as i0 from "@angular/core";
interface InternalDropdownOption<T> {
    data: T;
    id: string;
    grouper?: boolean;
}
export declare class SelectComponent<T> implements ControlValueAccessor, OnInit {
    private static nextId;
    placeholder: import("@angular/core").InputSignal<string>;
    multiple: import("@angular/core").InputSignal<boolean>;
    options: import("@angular/core").InputSignal<T[]>;
    optionLabel: import("@angular/core").InputSignal<keyof T | undefined>;
    optionValue: import("@angular/core").InputSignal<keyof T | undefined>;
    showClear: import("@angular/core").InputSignal<boolean>;
    filter: import("@angular/core").InputSignal<boolean>;
    checkmark: import("@angular/core").InputSignal<boolean>;
    filterBy: import("@angular/core").InputSignal<keyof T | (keyof T)[] | undefined>;
    group: import("@angular/core").InputSignal<boolean>;
    virtualScroll: import("@angular/core").InputSignal<boolean>;
    virtualScrollItemSize: import("@angular/core").InputSignal<number>;
    emptyMessage: import("@angular/core").InputSignal<string | null>;
    disabled: import("@angular/core").ModelSignal<boolean>;
    showOptions: import("@angular/core").ModelSignal<boolean>;
    value: import("@angular/core").WritableSignal<InternalDropdownOption<T> | null>;
    values: import("@angular/core").WritableSignal<InternalDropdownOption<T>[]>;
    filterValue: import("@angular/core").WritableSignal<string>;
    focusedIndex: import("@angular/core").WritableSignal<number>;
    componentId: string;
    /**
     * Computed que indica se todas as opções filtradas estão selecionadas.
     * Retorna `true` se todas as opções disponíveis (excluindo agrupadores) estiverem presentes
     * na lista de valores selecionados, e `false` caso contrário.
     * @returns {boolean} `true` se todas as opções filtradas estão selecionadas, `false` caso contrário.
     */
    allSelected: import("@angular/core").Signal<boolean>;
    /**
     * Retorna o item atualmente focado na lista de opções filtradas.
     * @returns O dado do item focado ou `null` caso nenhum item esteja focado.
     */
    focusedItem: import("@angular/core").Signal<NonNullable<T> | null>;
    /**
     * Computa e retorna a lista interna de opções do dropdown.
     * - Se as opções estiverem agrupadas (`group()` retorna verdadeiro),
     *   utiliza `_grouperToFlat` para transformar as opções agrupadas em uma lista plana.
     * - Caso contrário, retorna as opções com IDs adicionados.
     * @returns Um array de `InternalDropdownOption<T>` representando as opções disponíveis para o componente select.
     */
    internalOptions: import("@angular/core").Signal<InternalDropdownOption<T>[]>;
    /**
     * Retorna uma string representando a seleção atual do componente.
     * - Se o modo múltiplo estiver ativado e mais de um item estiver selecionado,
     *   retorna uma mensagem traduzida indicando o número total de registros selecionados.
     * - Se apenas um item estiver selecionado, retorna o rótulo desse item.
     * - Se o modo múltiplo não estiver ativado, retorna o rótulo do item selecionado ou uma string vazia caso nenhum item esteja selecionado.
     * @returns {string} Texto representando a seleção atual.
     */
    print: import("@angular/core").Signal<any>;
    /**
     * Indica se o seletor está "limpo", ou seja, sem nenhum valor selecionado.
     * - No modo múltiplo (`multiple`), retorna `true` se não houver nenhum valor selecionado (`values` está vazio).
     * - No modo simples, retorna `true` se não houver valor selecionado (`value` é falsy).
     * @returns `true` se não houver seleção, `false` caso contrário.
     */
    isClean: import("@angular/core").Signal<boolean>;
    /**
     * Computed que indica se o estado de seleção "Selecionar Todos" está indeterminado.
     * Retorna `true` quando nem todos os itens filtrados estão selecionados e nem todos estão desmarcados,
     * ou seja, quando há uma seleção parcial dos itens disponíveis.
     * @returns {boolean} `true` se a seleção for parcial, `false` caso contrário.
     */
    selectAllIsIndeterminate: import("@angular/core").Signal<boolean>;
    /**
     * Retorna uma lista de opções filtradas com base no valor de busca (`filterValue`) e nos critérios definidos.
     * - Se o filtro estiver desabilitado ou o valor de busca estiver vazio, retorna todas as opções.
     * - Caso contrário, filtra as opções utilizando o(s) campo(s) especificado(s) em `filterBy`.
     * - Ignora opções que possuem a propriedade `grouper` definida.
     * @returns As opções filtradas conforme o valor de busca e critérios de filtro.
     */
    filteredOptions: import("@angular/core").Signal<InternalDropdownOption<T>[]>;
    readonly filterForm: FormGroup<{
        filter: FormControl<string>;
    }>;
    private _containerDiv;
    private _onChange;
    private _onTouched;
    private readonly _translateService;
    constructor();
    ngOnInit(): void;
    /**
     * Define o valor selecionado do componente select.
     * @param value O valor a ser definido. Pode ser um objeto do tipo `T`, um array de `T` (quando múltipla seleção está habilitada), ou `null`.
     * @throws Se o modo múltiplo estiver ativado e o valor não for um array, lança um erro.
     * @throws Se o modo múltiplo estiver desativado e o valor for um array, lança um erro.
     * Este método mapeia o(s) valor(es) fornecido(s) para as opções internas do componente,
     * garantindo que apenas opções válidas sejam selecionadas conforme o modo de seleção (único ou múltiplo).
     */
    writeValue(value: T | T[] | null): void;
    /**
     * Registra uma função de callback que será chamada sempre que o valor do componente mudar.
     * @param onChange Função de callback que recebe o novo valor selecionado ou null.
     */
    registerOnChange(onChange: (value: T | T[] | null) => void): void;
    /**
     * Registra uma função de callback que será chamada quando o componente for tocado (perder o foco).
     * @param onTouched Função de callback a ser executada quando o componente for marcado como "tocado".
     */
    registerOnTouched(onTouched: () => void): void;
    /**
     * Define o estado de desabilitado do componente.
     * @param disabled Indica se o componente deve ser desabilitado (`true`) ou habilitado (`false`).
     */
    setDisabledState(disabled: boolean): void;
    /**
     * Alterna a exibição das opções do componente select.
     * Se o componente estiver desabilitado, não realiza nenhuma ação.
     * Caso contrário, inverte o estado de exibição das opções.
     */
    toggle(): void;
    /**
     * Seleciona um item no componente de seleção.
     * @param item O item a ser selecionado ou desmarcado.
     * Se o componente estiver desabilitado, a função retorna imediatamente.
     * No modo múltiplo, adiciona ou remove o item da lista de valores selecionados.
     * No modo simples, define o item como valor selecionado e fecha o dropdown.
     * Sempre notifica as mudanças e marca o componente como tocado.
     */
    selectItem(item: InternalDropdownOption<T>): void;
    /**
     * Limpa o valor selecionado no componente select.
     * Se o componente estiver desabilitado, não executa nenhuma ação.
     * Para seleção múltipla, remove todos os valores selecionados e notifica a alteração.
     * Para seleção única, define o valor como nulo e notifica a alteração.
     * Fecha o dropdown e marca o componente como "tocado".
     * Impede a propagação do evento do mouse.
     * @param event Evento do mouse que acionou a limpeza da seleção.
     */
    clear(event: MouseEvent): void;
    /**
     * Limpa o filtro do formulário, resetando o campo 'filter' do formulário de filtro.
     * Este método redefine o valor do campo 'filter' para seu estado inicial,
     * removendo qualquer texto ou valor previamente inserido pelo usuário.
     */
    clearFilter(): void;
    /**
     * Manipula o evento de redimensionamento da janela.
     * Fecha o dropdown de opções caso ele esteja visível ao redimensionar a janela.
     * @param _ Evento de redimensionamento da janela (não utilizado).
     */
    onWindowResize(_: Event): void;
    /**
     * Manipula o evento de clique no elemento container da seleção.
     * Este método alterna o estado de exibição do componente select e,
     * em seguida, define o foco no elemento container correspondente.
     */
    onContainerDivClick(): void;
    /**
     * Manipula eventos de teclado para navegação e seleção de opções no componente select.
     * - 'ArrowDown': Move o foco para a próxima opção disponível.
     * - 'ArrowUp': Move o foco para a opção anterior.
     * - 'Tab': Seleciona a opção atualmente focada e fecha o dropdown.
     * - 'Enter': Seleciona a opção focada se o dropdown estiver aberto, ou alterna a abertura do dropdown.
     * - 'Escape': Fecha o dropdown.
     * - ' ': (barra de espaço) Seleciona a opção focada se o dropdown estiver aberto, ou alterna a abertura do dropdown.
     * Previne o comportamento padrão do navegador quando necessário para garantir a navegação adequada pelo teclado.
     * @param event O evento de teclado disparado pelo usuário.
     */
    onKeyDown(event: KeyboardEvent): void;
    /**
     * Retorna o rótulo (label) associado a uma opção fornecida.
     * @param option - A opção do tipo T para a qual o rótulo deve ser obtido.
     * @returns O rótulo da opção como uma string.
     */
    getOptionLabel(option: T): string;
    /**
     * Função de trackBy utilizada em diretivas *ngFor para otimizar a renderização de listas.
     * Retorna o identificador único (`id`) de cada item do tipo `InternalDropdownOption<T>`.
     * @param _ - Índice do item na lista (não utilizado).
     * @param item - O item atual da lista do tipo `InternalDropdownOption<T>`.
     * @returns O identificador único do item como uma string.
     */
    trackById(_: number, item: InternalDropdownOption<T>): string;
    /**
     * Verifica se a opção fornecida está selecionada.
     * @param option - A opção interna do dropdown a ser verificada.
     * @returns `true` se a opção estiver selecionada, caso contrário `false`.
     */
    isOptionSelected(option: InternalDropdownOption<T>): boolean;
    /**
     * Alterna a seleção de todos os itens disponíveis.
     * Se o modo múltiplo estiver ativado, seleciona todos os itens filtrados que não são agrupadores
     * caso nem todos estejam selecionados, ou limpa a seleção caso todos já estejam selecionados.
     * Após a alteração, notifica a mudança de valor.
     */
    toggleSelectAll(): void;
    /**
     * Retorna o rótulo (label) de uma opção fornecida.
     * Este método utiliza a propriedade definida por `optionLabel` para extrair o valor do rótulo da opção.
     * Caso `optionLabel` não esteja definido, retorna a representação em string da própria opção.
     * @private
     * @param option A opção da qual o rótulo será extraído.
     * @returns O rótulo da opção como uma string.
     */
    private _getLabelFromOption;
    /**
     * Valida as entradas do componente de seleção.
     * Este método verifica se as opções fornecidas são válidas. Caso as opções sejam objetos,
     * garante que a propriedade `optionLabel` esteja definida, lançando um erro caso contrário.
     * Se não houver opções, a validação é ignorada.
     * @private
     * @throws {Error} Se as opções forem objetos e `optionLabel` não estiver definido.
     */
    private _validateInputs;
    /**
     * Fecha o dropdown de opções do componente select.
     * Este método oculta as opções disponíveis e redefine o índice do item focado para -1,
     * indicando que nenhum item está atualmente focado.
     * @private
     */
    private _closeDropdown;
    /**
     * Adiciona um identificador único a cada opção fornecida.
     * Para cada item no array de opções, gera um objeto `InternalDropdownOption` contendo o dado original
     * e um campo `id` único baseado no timestamp atual e no índice do item. Caso a opção seja um grupo
     * (detectado pela presença de um array `items`), adiciona também a propriedade `grouper: true`.
     * @private
     * @param options Array de opções do tipo `T` a serem processadas.
     * @returns Um array de objetos `InternalDropdownOption<T>` com identificadores únicos.
     */
    private _addIdToOptions;
    /**
     * Converte uma lista de opções possivelmente agrupadas em uma lista plana de opções.
     * Para cada opção que possui um agrupador (`grouper`) e um array de itens em `data.items`,
     * adiciona a opção do agrupador e, em seguida, adiciona cada item do grupo como uma nova opção
     * individual, atribuindo um `id` único para cada item do grupo.
     * Caso a opção não seja um agrupador, ela é adicionada diretamente ao resultado.
     * @private
     * @param options Lista de opções internas do dropdown, podendo conter agrupadores.
     * @returns Lista plana de opções, incluindo agrupadores e seus itens expandidos.
     */
    private _grouperToFlat;
    /**
     * Move o foco para a próxima opção disponível na lista, ignorando opções que sejam agrupadores.
     * @private
     * @param options Lista de opções internas do dropdown.
     */
    private _focusNextOption;
    /**
     * Move o foco para a opção anterior na lista, ignorando opções do tipo "grouper".
     * @private
     * @param options Lista de opções internas do dropdown.
     */
    private _focusPreviousOption;
    /**
     * Rola a lista de opções para garantir que a opção atualmente focada esteja visível.
     * Este método obtém o ID da opção atualmente focada a partir da lista de opções filtradas.
     * Se um ID válido for encontrado, busca o elemento correspondente no DOM e utiliza
     * `scrollIntoView` para rolar até a opção, alinhando-a ao bloco mais próximo.
     * @private
     */
    private _scrollToFocusedOption;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent<any>, "s-select", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "checkmark": { "alias": "checkmark"; "required": false; "isSignal": true; }; "filterBy": { "alias": "filterBy"; "required": false; "isSignal": true; }; "group": { "alias": "group"; "required": false; "isSignal": true; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; "isSignal": true; }; "virtualScrollItemSize": { "alias": "virtualScrollItemSize"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "showOptions": { "alias": "showOptions"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "showOptions": "showOptionsChange"; }, never, never, true, never>;
}
export {};
