interface Success<T> {
    data: T;
    error: null;
}
interface Failure<E extends Error = Error> {
    data: null;
    error: E;
}
type Result<T extends any, E extends Error = Error> = Success<T> | Failure<E>;
type SafeFunctionPayload<T> = () => Promise<T> | T;
interface SafeFunctionOption {
    retries?: number;
    retryDelay?: number;
    timeout?: number;
}
type SafeFunctionResult<T, E extends Error = Error> = Promise<Result<T, E>>;
type SafeSyncFunctionPayload<T> = () => T;
type SafeSyncFunctionResult<T, E extends Error = Error> = Result<T, E>;

declare class TimeoutError extends Error {
    constructor(ms: number);
}

declare const sleep: (ms: number) => Promise<unknown>;

declare const safe: <T, E extends Error = Error>(fn: SafeFunctionPayload<T>, options?: SafeFunctionOption) => SafeFunctionResult<T, E>;
declare const syncSafe: <T, E extends Error = Error>(fn: SafeSyncFunctionPayload<T>) => SafeSyncFunctionResult<T, E>;

export { Failure, Result, SafeFunctionOption, SafeFunctionPayload, SafeFunctionResult, SafeSyncFunctionPayload, SafeSyncFunctionResult, Success, TimeoutError, safe, sleep, syncSafe };