import { PreparedEvents } from '../config/definitions/parts/events';
declare type AnyFunction = (...args: any[]) => any;
export declare type EventInvokerAsync<P extends AnyFunction = any> = (...args: Parameters<P>) => Promise<any>;
export declare type EventInvokerSync<P extends AnyFunction = any> = (...args: Parameters<P>) => any;
export default class FuncUtils {
    /**
     * Creates an async closure for invoking async functions in a chain.
     * @param functions
     * @param breakChainOn
     * Indicates if the chain execution should stop when a function has returned some value
     * (value is also returned from the invoker) or when the provided function returns true.
     */
    static createAsyncChainInvoker<T extends AnyFunction>(functions: T[], breakChainOn: "ReturnValue" | false | ((...args: Parameters<T>) => boolean)): EventInvokerAsync<T>;
    /**
     * Creates an async closure for invoke a function or functions.
     * @param func
     */
    static createFuncAsyncInvoker<T extends AnyFunction>(func: T[] | T): EventInvokerAsync<T>;
    /**
     * Creates an async closure for invoking functions.
     * @param functions
     */
    static createFuncArrayAsyncInvoker<T extends AnyFunction>(functions: T[]): EventInvokerAsync<T>;
    /**
     * Creates an sync closure for invoke a function or functions.
     * @param func
     */
    static createFuncSyncInvoker<T extends AnyFunction>(func: T[] | T): EventInvokerSync<T>;
    /**
     * Creates an sync closure for invoke a function.
     * @param functions
     */
    static createFuncArraySyncInvoker<T extends AnyFunction>(functions: T[]): EventInvokerSync<T>;
    /**
     * Creates a function safe caller which catch thrown errors,
     * log them and triggers the error event.
     * @param func
     * @param errorEvent
     * @param beforeErrorMsg
     */
    static createSafeCaller<T extends AnyFunction>(func: T, beforeErrorMsg?: string, errorEvent?: PreparedEvents['error']): EventInvokerAsync<T>;
    /**
     * Calls a function safe.
     * It means that all thrown errors will be caught.
     * In this case, the failureReturnValue will be returned.
     * @param func
     * @param args
     * @param failureReturnValue
     */
    static callSafe<T extends (...args: any[]) => any, FR>(func: T, args: Parameters<T>, failureReturnValue: FR): ReturnType<T> | FR;
}
export {};