import { ChildDescriptor, FieldDescriptor, Filter, FilterProvider, Sort, SortingProvider, UnitMetadata } from "./metadata/UnitMetadata.js";
import { DataUnitAction, ExecutionContext } from "./state/action/DataUnitAction.js";
import { LoadDataRequest } from "./loading/LoadDataRequest.js";
import { LoadDataResponse } from "./loading/LoadDataResponse.js";
import { PaginationInfo } from "./loading/PaginationInfo.js";
import { DataUnitEventOptions, DUActionInterceptor, HideFieldOptions, LoadDataParams, QuickFilter, Record, SavedRecord, SelectionMode, WaitingChange } from "./interfaces/dataUnit.js";
import { Change } from "./Changes.js";
import { SelectionInfo } from "./SelectionInfo.js";
/***
 * `DataUnit`: Atua como uma camada de abstração entre o back-end e a interface do usuário.
*/
export default class DataUnit {
    static CHANGING_PAGE_LOADING_SOURCE: string;
    static ALL_RECORDS_SELECTION_SOURCE: string;
    static DEFAULT_DATAUNIT_NAME: string;
    private _uuid;
    private _name;
    private _observers;
    private _sortingProvider?;
    private _filterProviders;
    private _stateManager;
    private _interceptors;
    private _pageSize;
    private _childByName;
    private _parentDataUnit;
    private _loadingLockers;
    private _savingLockers;
    private _defaultSorting;
    private _allowReleaseCallbacks;
    private _waitingToReload;
    private _cancelPagination;
    private _isMultipleEdition;
    private _fieldSourceValue;
    metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
    dataLoader?: (dataUnit: DataUnit, request: LoadDataRequest) => Promise<LoadDataResponse>;
    saveLoader?: (dataUnit: DataUnit, changes: Array<Change>) => Promise<Array<SavedRecord>>;
    removeLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<string>>;
    recordLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<Record>>;
    allRecordsLoader?: (dataUnit: DataUnit) => Array<Record> | undefined;
    constructor(name?: string, parentDataUnit?: DataUnit);
    /**
     * Desfaz vinculos do DataUnit. Chamado quando o DU não é mais necessário.
     */
    release(): void;
    /**
     * Remove callbacks registrados internamente no dataunit, é util
     * para evitar memory leak em cenários onde o dataunit é reaproveitado em cache.
     *
     * Callbacks que são liberados:
     * - Filters Providers
     * - Interceptors
     * - Observers
     * - Sorting Providers
     */
    releaseCallbacks(): void;
    /**
     * Adiciona uma propriedade transacional que será envida aos
     * loaders (dataLoader, saveLoader, removeLoader e recordLoader) na chamada.
     * Essas propriedades serão limpas ao final da execução de cada método.
     *
     * @param name - Nome da propriedade
     * @param value - Valor da propriedade
     *
     */
    addGlobalLoaderProp(name: string, value: string): void;
    /**
     * Retorna as propriedades transacionais adicionados anteriores à chamada.
     *
     * @returns - Todas as propriedades desde o final do último loader.
     */
    getGlobalLoaderProps(): Map<string, string>;
    get dataUnitId(): string;
    /**
     * Retorna se o dataUnit está com recarregamento pendente.
     */
    isWaitingToReload(): boolean;
    /**
     * Define se o dataUnit tem um recarregamento pendente.
     * @param isWaiting
     */
    setWaitingToReload(isWaiting: boolean): void;
    /**
     * Informa se a paginação deve ser cancelada.
     */
    get cancelPagination(): boolean;
    /**
     * Informa se a paginação deve ser cancelada.
     */
    set cancelPagination(cancelPagination: boolean);
    /**
     * Informa se o DataUnit está no modo de edição de múltiplos registros.
     */
    get isMultipleEdition(): boolean;
    /**
     * Define se o DataUnit está no modo de edição de múltiplos registros.
     */
    set isMultipleEdition(isMultipleEdition: boolean);
    /**
     *
     * Obtém o nome de identificação do DataUnit (geralmente em formato de URI - Uniform Resource Identifier).
     *
     * @returns - Nome de identificação do DataUnit.
     *
    */
    get name(): string;
    /**
     *
     * Obtém o valor convertido de acordo com o tipo do campo.
     *
     * @param fieldName - Identificador do campo.
     * @param newValue - Novo valor que será atribuído ao campo pós validação.
     *
     * @returns - Novo valor convertido em um tipo valido.
     *
    */
    private validateAndTypeValue;
    /**
     *
     * Trata as Actions do DataUnit Parent
     *
     *
    */
    private onDataUnitParentEvent;
    /**
     *
     * Obtém chave única para identificação do FilterProvider.
     *
     * @param provider - Interface FilterProvider na qual será retornada uma chave correspondente.
     *
     * @returns - A chave do provider.
     *
    */
    private getFielterProviderKey;
    /**
     *
     * Executa o carregamento dos registros.
     *
     * @param request - Dados da requisição para carregamento dos registros.
     * @param executionCtx - Contexto de execução do carregamento dos registros do DataUnit.
     * @param checkLastFilter - Habilita a verificação da última requisição, evitando carga desnecessária.
     *
     * @returns - Registros do DataUnit.
     *
    */
    private executeLoadData;
    private requestSelectFirst;
    private isSameRequest;
    /**
     *
     * Carrega os metadados do DataUnit.
     *
     * @param executionCtx - Contexto de execução do carregamento dos metadados do DataUnit.
     *
     * @returns - Metadados carregados.
     *
    */
    loadMetadata(executionCtx?: ExecutionContext): Promise<UnitMetadata | void>;
    loadDataWithParams({ source, keepSelection, selectFirstRecord, executionCtx, checkLastFilter, quickFilter }: LoadDataParams): Promise<LoadDataResponse>;
    /**
     *
     * Carrega os registros do DataUnit.
     *
     * @param quickFilter - Filtros a serem aplicados.
     * @param executionCtx - Contexto de execução do carregamento dos registros.
     * @param checkLastFilter - Habilita a verificação da última requisição, evitando carga desnecessária.
     *
     * @returns - Registros requisitados.
     *
    */
    loadData(quickFilter?: QuickFilter, executionCtx?: ExecutionContext, checkLastFilter?: boolean, source?: string, selectFirstRecord?: boolean, keepSelection?: boolean): Promise<LoadDataResponse>;
    /**
     *
     * Alterna entre os registros por número de página.
     *
     * @param page - Número da página desejada.
     * @param executionCtx - Contexto de execução do carregamento dos registros do DataUnit.
     *
     * @returns - Registros da página desejada.
     *
    */
    gotoPage(page: number, executionCtx?: ExecutionContext): Promise<LoadDataResponse | void>;
    /**
     *
     * Vai para os registros da página seguinte.
     *
     * @param executionCtx - Contexto de execução do carregamento dos registros do DataUnit.
     *
     * @returns - Registros da página seguinte.
     *
    */
    nextPage(executionCtx?: ExecutionContext): Promise<LoadDataResponse | void>;
    /**
     *
     * Vai para os registros da página anterior.
     *
     * @param executionCtx - Contexto de execução do carregamento dos registros do DataUnit.
     *
     * @returns - Registros da página anterior.
     *
    */
    previousPage(executionCtx?: ExecutionContext): Promise<LoadDataResponse | void>;
    private getLoadDataRequest;
    private notifySavingData;
    private getBeforeSavePromisses;
    /**
     *
     * Salva o estado do registro do DataUnit.
     *
     * @param executionCtx - Contexto de execução da persistencia do registro do DataUnit.
     *
     * @returns - Resposta da solicitação.
     *
    */
    saveData(executionCtx?: ExecutionContext): Promise<void>;
    /**
     *
     * Retorna as alterações a serem salvas no DataUnit atual.
     *
     *
     *
     * @returns - Mudanças realizadas no DataUnit atual
     *
    */
    buildChangesToSave(): Array<Change>;
    buildChangesToSaveFromChild(allChanges: Array<Change>, dataUnit: DataUnit): void;
    /**
     *
     * Retorna todas as alterações do DataUnit a serem salvas, incluindo no nível Master e Detail.
     *
     *
     *
     * @returns - Todas as mudanças realizadas no DataUnit, tanto Master quanto Detail;
     *
    */
    getAllChangesToSave(): Array<Change>;
    /**
     *
     * Remove o registro selecionado.
     *
     * @param buffered - Se será utilizado buffer na solicitação.
     * @param silent - Define se haverá mensagem de confirmação da remoção
     *
     * @returns - ID's dos registros removidos.
     *
    */
    removeSelectedRecords(buffered?: boolean, silent?: boolean): Promise<Array<string>>;
    /**
     *
     * Efetua requisição para remoção dos registros.
     *
     * @param recordIds - Lista de IDs dos registros que serão removidos.
     * @param cachedRecords - Dados dos registros que serão removidos.
     * @param buffered - Se será utilizado buffer na solicitação.
     * @param executionCtx - Contexto de execução da remoção do registro do DataUnit.
     * @param silent - Define se haverá mensagem de confirmação da remoção
     *
     * @returns - ID's dos registros removidos.
     *
    */
    removeRecords(recordIds: Array<string>, cachedRecords: Array<Record>, buffered?: boolean, executionCtx?: ExecutionContext, silent?: boolean): Promise<Array<string>>;
    /**
     *
     * Obtém o valor do campo em seu formato/tipo correto a partir de uma string.
     *
     * @param fieldName - Nome do campo que terá o tipo identificado para conversão.
     * @param value - Texto que será convertido de acordo com o tipo identificado no campo.
     *
     * @returns - Valor convertido ou ele mesmo.
     *
    */
    valueFromString(fieldName: string, value: string): any;
    /**
     *
     * Converte o valor informado para texto de acordo com o tipo do campo informado.
     *
     * @param fieldName - Nome do campo utilizado para buscar o tipo de dado com o padrão de conversão para string.
     * @param value - Valor a ser convertido.
     *
     * @returns - Valor informado convertido.
     *
    */
    valueToString(fieldName: string, value: any): string;
    /**
     *
     * Formata o valor do campo considerando as informações do descriptor.
     * Diferente do método "valueToString" que retorna o dado em valor textual,
     * getFormattedValue retorna uma informação amigável ao usuário, geralmente
     * usada na interface.
     *
     * @param fieldName - Nome do campo utilizado do qual se quer obter valor.
     * @param value (opcional) - O valor a ser convertido. Caso omitido pega do registro selecionado.
     *
     * @returns - Valor formatado.
     *
    */
    getFormattedValue(fieldName: string, value?: any): string;
    /**
     *
     * Adiciona um interceptor correspondente a uma ação do DataUnit para fazer um processamento customizado.
     *
     * @param interceptor - Interceptor a ser adicionado.
     *
    */
    addInterceptor(interceptor: DUActionInterceptor): void;
    /**
     *
     * Remove um interceptor da lista de interceptors.
     *
     * @param interceptor - Interceptor a ser removido.
     *
    */
    removeInterceptor(interceptor: DUActionInterceptor): void;
    /**
     *
     * Adiciona um FilterProvider.
     *
     * @param provider - FilterProvider que será adicionado.
     *
    */
    addFilterProvider(provider: FilterProvider): void;
    /**
     *
     * Remove um FilterProvider.
     *
     * @param provider - FilterProvider que será removido.
     *
    */
    removeFilterProvider(provider: FilterProvider): boolean;
    /**
     *
     * Obtém informações de paginação dos registros.
     *
     * @returns - Informações da paginação de registros.
    */
    getPaginationInfo(): PaginationInfo | void;
    /**
     *
     * Obtém informações de paginação dos registros.
     *
     * @returns - Informações da paginação de registros.
    */
    updatePagination(info: PaginationInfo): Promise<boolean>;
    /**
     *
     * Define a lógica de ordenação dos registros.
     *
     * @param provider - Objeto usado para definir a propriedade sortingProvider da instância da classe.
     *
     */
    set sortingProvider(provider: SortingProvider);
    /**
     *
     * Define a ordenação padrão.
     *
     * @param sorting - Ordenação padrão.
     *
     */
    set defaultSorting(sorting: Array<Sort>);
    /**
     *
     * Define a propriedade metadata da instância da classe com um novo valor e chama o método dispatchAction para notificar os observers da aplicação sobre a mudança.
     *
     */
    set metadata(md: UnitMetadata);
    /**
     *
     * Obtém os metadados do DataUnit.
     *
     */
    get metadata(): UnitMetadata;
    /**
    *
    * Obtém informações da ligação para um DataUnit filho.
    *
    * @param name - Nome do DataUnit que se deseja.
    *
    * @returns - As informações sobre a ligação solicitada. Pode retornar undefined.
    *
    */
    getChildInfo(name: string): ChildDescriptor | undefined;
    /**
     *
     * Define a propriedade records da instância da classe com um novo valor e chama o método dispatchAction para notificar os observers da aplicação sobre a mudança,
     * mantendo a seleção definida anteriormente.
     *
     */
    setRecordsKeepingSelection(records: Array<Record>): void;
    /**
     *
     * Define a propriedade records da instância da classe com um novo valor e chama o método dispatchAction para notificar os observers da aplicação sobre a mudança.
     *
     */
    set records(records: Array<Record>);
    /**
     *
     * Obtém todos os registros atuais.
     *
     * @returns - Todos os registros atuais.
     *
     */
    get records(): Array<Record>;
    /**
     *
     * Define a quantidade de registros que será exibido por página.
     *
     * @param size - Quantidade de registros que será exibido por página.
     *
     */
    set pageSize(size: number);
    /**
     *
     * Obtém a quantidade de registros que está sendo exibido por página.
     *
     * @returns - Quantidade de registros exibidos por página.
     *
     */
    get pageSize(): number;
    /**
     *
     * Obtém os registros modificados e ainda não salvos no DataUnit.
     *
     * @returns - Lista dos registros em edição.
     *
     */
    getModifiedRecords(): Array<Record>;
    /**
     *
     * Obtém os registros adicionados no DataUnit.
     *
     * @returns - Lista dos registros adicionados.
     *
     */
    getAddedRecords(): Array<Record>;
    /**
     *
     * Obtém metadados de um campo específico.
     *
     * @param fieldName - Identificador do campo.
     *
     * @returns - Metadados do campo informado.
     */
    getField(fieldName: string): FieldDescriptor | undefined;
    /**
     *
     * Adiciona um novo registro.
     *
     * @param executionCtx - Contexto de execução da inserção do dado no DataUnit.
     *
    */
    addRecord(executionCtx?: ExecutionContext): Promise<boolean>;
    /**
     *
     * Efetua a cópia do registro selecionado.
     *
     * @param executionCtx - Contexto de execução da cópia do dado do DataUnit.
     *
    */
    copySelected(executionCtx?: ExecutionContext): void;
    private getRecordsByDataUnit;
    private getParentRecordId;
    /**
     *
     * Retorna se a alteração no campo já foi concluída ou se ainda está incompleta.
     *
     * @param fieldName - Identificador do campo a ser verificado.
     *
     * @returns - Verdadeiro se ainda está pendente.
     *
    */
    waitingForChange(fieldName: string): boolean;
    /**
     *
     * Obtém valor do campo desejado.
     *
     * @param fieldName - Identificador do campo a ser buscado.
     *
     * @returns - Valor do campo.
     *
    */
    getFieldValue(fieldName: string): any;
    /**
     *
     *  Insere valor no campo desejado.
     *
     * @param fieldName -Identificador do campo a ser modificado.
     * @param newValue - Valor a ser inserido no campo.
     * @param records - Indica quais registros foram afetados pela alteração no valor do campo.
     * @param options - Configurações do evento
     * @returns - Promise que será resolvida quando o novo valor for persistido no state.
     *
     */
    setFieldValue(fieldName: string, newValue: any, records?: Array<string>, options?: DataUnitEventOptions): Promise<boolean>;
    private areEquivalentValues;
    /**
     *
     *  Marca campos como inválidos.
     *
     * @param fieldName - Nome do campo inválido.
     * @param message - Mensagem descrevendo o motivo da invalidade.
     * @param recordId - Indica qual registro está com o campo inválido.
     *
    */
    setInvalidField(fieldName: string, message: string, recordId: string): void;
    /**
     *
     *  Cancela o saving exibindo os campos invalidos.
     *
     * @param filds - Lista dos campos
     * @param recordId - Indica qual registro está com os campos inválido.
     *
    */
    savingCanceled(fields: Array<{
        name: string;
        message: string;
    }>, recordId: string): void;
    /**
     *
     *  Limpa campos inválidos.
     *
     * @param recordId - Indica em qual registro o campo não está mais inválido.
     * @param fieldName - Nome do campo. Caso omitido, todos os campos serão limpos.
     *
    */
    clearInvalid(recordId: string, fieldName?: string): void;
    /**
     *
     *  Obtém a mensagem de campo inválido para determinado registro.
     *
     * @param recordId - Identificador do registro.
     * @param fieldName - Nome do campo.
     *
    */
    getInvalidMessage(recordId: string, fieldName: string): string | undefined;
    /**
     *
     *  Inicia alteração no campo.
     *
     * @param fieldName - Identificador do campo a ser modificado.
     * @param waitingChange - Informa que uma mudança irá iniciar.
     *
    */
    startChange(fieldName: string, waitingChange: WaitingChange): void;
    /**
     *
     *  Cancela o início de uma alteração no campo.
     *
     * @param fieldName - Identificador do campo.
     *
    */
    cancelWaitingChange(fieldName: string): void;
    /**
     * Retorna se existe alterações pendentes.
     * @returns Verdadeiro se existir pendências de modificações.
    */
    hasWaitingChanges(): boolean;
    /**
     *
     * Seleciona o primeiro registro.
     *
     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
     *
    */
    selectFirst(executionCtx?: ExecutionContext): void;
    /**
     *
     * Seleciona o último registro.
     *
     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
     *
    */
    selectLast(executionCtx?: ExecutionContext): void;
    /**
     *
     * Seleciona múltiplos registros por índice.
     *
     * @param selection - Índices desejados para a seleção.
     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
     *
    */
    setSelectionByIndex(selection: Array<number>, executionCtx?: ExecutionContext): void;
    /**
     *
     * Seleciona múltiplos registros por ID ou todos os registros (multipágina) .
     *
     * @param selection - IDs para selecionar ou o modo de seleção completo.
     * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
     *
     *
    */
    setSelection(selection: Array<string> | SelectionMode.ALL_RECORDS, executionCtx?: ExecutionContext): Promise<SelectionInfo>;
    /**
     *
     * Limpa a seleção.
     *
     * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
     *
    */
    clearSelection(executionCtx?: ExecutionContext): void;
    /**
     *
     * Atualiza a seleção dos registros atuais.
     *
     * @param selection - IDs dos registros selecionados no snapshot atual
     * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
     * @returns - Informações sobre a seleção.
    */
    updatePageSelection(selection?: Array<string>, executionCtx?: ExecutionContext): Promise<SelectionInfo | undefined>;
    private updatePageSelectionAll;
    /**
     * Seleciona todos os registros da página.
     *
     * @returns - Informações sobre a seleção.
     */
    selectAllRecords(): Promise<SelectionInfo | undefined>;
    /**
     * Desseleciona todos os registros da página.
     *
     * @returns - Informações sobre a seleção.
     */
    unSelectAllRecords(): Promise<SelectionInfo | undefined>;
    /**
     *
     * Obtém informações sobre a seleção atual.
     *
     * @returns - Objeto com informações como registros selecionados e seleção por critério.
     *
     **/
    getSelectionInfo(): SelectionInfo;
    /**
     *
     * Retorna apenas um registro selecionado no Dataunit
     *
     * @returns - Registro selecionado.
     *
    */
    getSelectedRecord(): Record | undefined;
    /**
     * Retorna o DataUnit pai
     *
     * @returns DataUnit pai ou undefined
     */
    getParentDataUnit(): DataUnit | undefined;
    /**
     *
     * Limpa todos os registros do DataUnit
     *
     *
    */
    clearDataUnit(): void;
    /**
     *
     * Seleciona o próximo registro.
     *
     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
     *
     *
    */
    nextRecord(executionCtx?: ExecutionContext): Promise<void>;
    /**
     *
     * Seleciona o registro anterior.
     *
     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
     *
    */
    previousRecord(executionCtx?: ExecutionContext): Promise<void>;
    /**
     *
     * Cancela edição do registro atual.
     *
     * @param executionCtx - Contexto de execução do cancelamento da seleção dos registros.
     * @param silent: Define se haverá mensagem de confirmação do cancelamento
     *
    */
    cancelEdition(executionCtx?: ExecutionContext, fromParent?: boolean, silent?: boolean): Promise<boolean>;
    /**
     *
     * Retorna se existe algum tipo de alteração pendente.
     *
     * @param ignoreChildren: Define se deverá ignorar alterações pendentes no DataUnit filho.
     * @returns Verdadeiro se existir alterações pendentes.
     *
    */
    isDirty(ignoreChildren?: boolean): boolean;
    /**
     *
     * Retorna se existe alterações pendentes no DataUnit pai.
     *
     * @returns Verdadeiro se existir alterações pendentes e Falso caso não exista alterações ou não exista DataUnit pai.
     *
     */
    isParentDirty(): boolean;
    /**
     *
     * Retorna se existe algum DataUnit detail com alterações pendentes.
     *
     * @returns Verdadeiro se existir alterações pendentes em algum DataUnit detail.
     *
    */
    private childrenIsDirty;
    /**
     *
     * Retorna se existe algum registro em modo de edição.
     *
     * @returns Verdadeiro se existir alterações de registros pendentes.
     *
    */
    hasDirtyRecords(): boolean;
    /**
     *
     * Retorna se existir uma pagina seguinte a atual na paginação.
     *
     * @returns Verdadeiro se existir uma próxima página.
     *
    */
    hasNext(): boolean;
    /**
     *
     * Retorna se existe uma página anterior a atual na paginação.
     *
     * @returns Verdadeiro se existir uma página anterior.
     *
    */
    hasPrevious(): boolean;
    /**
     *
     * Verifica se um registro é proveniente de inclusão.
     *
     * @param recordId - O id do registro a ser verificado.
     * @returns Verdadeiro se o id solicitado é de um registro novo.
     *
    */
    isNewRecord(recordId: string): boolean;
    /**
     *
     * Retorna se existe pelo menos um registro novo.
     *
     * @returns Verdadeiro se algum registro foi adicionado.
     *
    */
    hasNewRecord(): boolean;
    /**
     *
     * Retorna se existe pelo menos um registro novo.
     *
     * @returns Verdadeiro se algum registro foi adicionado.
     *
    */
    hasCopiedRecord(): boolean;
    /**
     *
     * Retorna se a informação do estado anterior está salva, permitindo desfazer a ação.
     *
     * @returns Verdadeiro se for possível desfazer a ação.
     *
    */
    canUndo(): boolean;
    /**
     *
     * Retorna se a informação do estado futuro está salva, permitindo refazer a ação.
     *
     * @returns Verdadeiro se for possível refazer a ação.
     *
    */
    canRedo(): boolean;
    /**
     *
     * Desfaz a última ação.
     *
     * @param executionCtx - Contexto de execução de desfazer a última ação.
     *
     *
    */
    undo(executionCtx?: ExecutionContext): void;
    /**
     *
     * Refaz a última ação.
     *
     * @param executionCtx - Contexto de execução de refazer a última ação.
     *
    */
    redo(executionCtx?: ExecutionContext): void;
    /**
     *
     * Obtém a representação textual do DataUnit, nesse caso, o nome do DataUnit.
     *
     * @returns - Valor contido na propriedade name.
     *
    */
    toString(): string;
    /**
     *
     * Lança ação do DataUnit para que sejam processadas.
     *
     * @param actionType - Tipo de ação que será executada.
     * @param payload - Dados que serão processados na ação.
     * @param executionCtx - Contexto de execução de lançar a ação que será executada.
     *
     * @returns - Verdadeiro se ação iniciada.
     *
    */
    private dispatchAction;
    /**
     *
     * Notifica os interceptors de que uma ação foi executada, para que cada interceptor possa fazer sua respectiva tratativa dos dados.
     *
     * @param action - Ação que foi executada.
     * @param interceptors - Interceptors que serão notificados.
     *
     * @returns - Ação executada no DataUnit.
     *
    */
    private intercept;
    /**
     *
     * Processa as ações no DataUnit e notifica os observers.
     *
     * @param action - Ações em execução no DataUnit.
     *
    */
    private doDispatchAction;
    /**
     *
     * Cria um dataunit filho.
     *
     * @param name - Nome do dataunit filho.
     *
    */
    getChildDataunit(name: string): DataUnit;
    /**
     *
     * Remove um dataunit filho.
     *
     * @param name - Nome do dataunit filho.
     *
    */
    removeChildDataunit(name: string): void;
    /**
     *
     * Adiciona um novo observer no DataUnit.
     * Ela vai ser chamada sempre que uma ação for despachada (dispatchAction()).
     *
     * @param observer - Função que recebe como parâmetro as ações que serão monitoradas.
     * @param uuid - Identificador do observer. Quando não informado, será gerado um identificador aleatório.
    */
    subscribe(observer: (action: DataUnitAction, options?: DataUnitEventOptions) => void | Promise<void>, uuid?: string): string;
    /**
     *
     * Remove um observer existente.
     *
     * @param observer - Observer que se deseja remover.
     * @param uuid - Identificador do observer. Quando não informado o delete removera com base no equals do observer.
    */
    unsubscribe(observer: Function, uuid?: string): void;
    /**
     *
     * Recarrega registro selecionado com dados atualizados do servidor.
     *
     * @returns - Dados atualizados do registro selecionado.
     *
    */
    reloadCurrentRecord(): Promise<Array<Record>>;
    /**
     *
     * Obtém a estrutura de ordenação das colunas dos dados.
     *
     * @returns - Lista dos ordenáveis por prioridade.
     *
    */
    getSort(): Array<Sort> | undefined;
    /**
     *
     * Obtém todos os filtros de dados.
     *
     * @returns - Lista de filtros.
     *
    */
    getFilters(): Array<Filter> | undefined;
    /**
     *
     * Obtém as informações da última carga de dados.
     *
     * @returns - As informações de filtro e paginação.
     *
    */
    getLastLoadRequest(): LoadDataRequest | undefined;
    /**
     *
     * Obtém os filtros aplicados.
     *
     * @returns - Lista de filtros.
     *
    */
    getAppliedFilters(): Array<Filter> | undefined;
    /**
     *
     * Habilita um campo do DataUnit
     * @param fieldName - nome do campo para ser habilitado.
     *
    */
    enableField(fieldName: string): void;
    /**
     *
     * Desabilita um campo do DataUnit
     * @param fieldName - nome do campo para ficar desabilitado.
     *
    */
    disableField(fieldName: string): void;
    /**
     *
     * Deixa um campo do DataUnit invisível
     * @param fieldName - nome do campo para ficar invisível.
     *
    */
    hideField(fieldName: string, options?: HideFieldOptions): void;
    /**
     *
     * Deixa um campo do DataUnit visível
     * @param fieldName - nome do campo para ficar visível.
     *
    */
    showField(fieldName: string): void;
    /**
     *
     * Obtém todos os registros selecionados.
     *
     * @returns - Lista de registros selecionados.
     *
     * @deprecated - Utilize o método `getSelectionInfo()` para obter os registros selecionados.
     * Devido a seleção virtual baseada em critérios e ordenação (ALL_RECORDS), esse
     * método foi descontinuado e pode retornar erros no caso da seleção virtual.
     *
    */
    getSelectedRecords(): Array<Record> | undefined;
    /**
     *
     * Obtém ids dos registros selecionados.
     *
     * @returns - Lista com id de todos os registros selecionados.
     *
     * @deprecated - Utilize o método `getSelectionInfo()` para obter os registros selecionados.
     * Devido a seleção virtual baseada em critérios e ordenação (ALL_RECORDS), esse
     * método foi descontinuado e pode retornar erros no caso da seleção virtual.
     *
    */
    getSelection(): Array<string>;
    /**
     * Adiciona um campo stand-alone ao dataUnit.
     *
     * @deprecated - metodo depreciado, utilizar o metodo addField
     */
    addStandAloneField(): void;
    /**
     * Adiciona um campo stand-alone ao dataUnit.
     *
     * @param field - Campo a ser adicionado.
     */
    addField(field: Omit<FieldDescriptor, 'standAlone'>): void;
    /**
     * Adiciona um locker para impedir o carregamento dos registros do dataUnit.
     * @returns Retorna uma função responsável por liberar o lock adicionado.
     */
    addLoadingLocker(): Function;
    set allowReleaseCallbacks(allow: boolean);
    /**
     * Adiciona um mapeamento de origem dos dados de um determinado campo
     */
    addSourceFieldValue(sourceFieldName: string, targetFieldName: string): void;
    /**
    * Retornar o campo de origem dos dados caso exista mapeamento
    */
    getSourceFieldValue(sourceFieldName: string): string | undefined;
    private processLoadingLockers;
}
export { Record, Change, SelectionInfo, SelectionMode, LoadDataParams, DUActionInterceptor, SavedRecord, WaitingChange, QuickFilter, DataUnitEventOptions, HideFieldOptions };