import { OperatorFunction } from 'rxjs';
/**
 * Expressão de valor qualquer
 */
export declare type fnBool = () => any;
/**
 * Utilitários e funções genéricas
 */
export declare class UtilsFn {
    /**
     * Retorna se o que foi passado é uma instância de array
     *
     * @param prop o que se deseja verificar
     * @returns se é um array ou não
     */
    static isArray(prop: any): boolean;
    /**
     * Em um processamento assíncrono com promises, permite que a thread aguarde o tempo informado.
     * @param ms tempo que deve aguardar, em ms
     */
    static sleep(ms: number): Promise<any>;
    /**
     * Lança uma rejeição com timeout caso a promise passada não seja resolvida a tempo
     * @param prom A promise que fará o processamento assíncrono
     * @param timeout O tempo que será aguardado, até um erro de timeout ocorrer
     */
    static timeout<T>(prom: Promise<T>, timeout: number): Promise<T>;
    /**
     * Semáforo de processamento para bloqueio de concorrência em determinada sessão
     * @param fn expressão que vai ser tratada como avaliação do lock, enquanto true, continuará em bloqueio
     * @param sleepMs Quantidade, em ms, que a expressão será reavaliada em um loop infinito, até que se torne verdadeira
     */
    static lock(fn: fnBool, sleepMs?: number): Promise<any>;
}
/**
 * Utilizado com rxjs, para executar um código após determinado tempo, apenas se o observable original ainda não completou
 * @param fn O código a ser executado
 * @param donefn função executada após finalização
 * @param errorFn função executada após finalização com erros. se não definido, utiliza a função de finalização
 * @param delay tempo para executar o código atrasado
 */
export declare function executeDelayed<T>(fn: () => void, donefn?: (data?: T) => void, errorFn?: (data?: T) => void, delay?: number): OperatorFunction<T, T>;
/**
 * executa uma ação após determinado tempo, apenas se o promise original ainda não completou
 * @param promise a promise com a operação assícrona
 * @param action a ação, que pode retornar ou não uma outra promise
 * @param doneAction a ação após completar, que pode retornar ou não uma outra promise
 * @param ms o tempo para aguardar a execução da ação
 * @example
 * await promiseDelayed(
 *  new Promise(r => setTimeout(r,5000)),
 *  ()=>this.global.loading.showLoading(),
 *  ()=>this.global.loading.hideLoading())
 */
export declare function promiseDelayed<T>(promise: Promise<T>, action: any, doneAction: any, errorAction: any, ms?: number): Promise<{} | T>;