import { Backend, CancelExecutionResult, EnqueueResult, ExecutionFilters, GetExecutionResult, ListExecutionAttemptsResult, ListExecutionsResult, PageRequest, ReRunExecutionResult, RescheduleExecutionResult } from "./backend";
import { Duration } from "./utils";
export declare let backend: Backend;
/**
 * Check if defer is enqueuing on the Defer cloud
 * @returns {boolean}
 */
export declare const deferEnabled: () => boolean;
export interface ExecutionMetadata {
    [key: string]: string;
}
export type NextRouteString = `/api/${string}`;
export interface Manifest {
    name: string;
    version: number;
    cron?: string;
    retry?: RetryPolicy;
    concurrency?: number | undefined;
    maxDuration?: number | undefined;
    maxConcurrencyAction: "keep" | "cancel" | undefined;
}
export interface RetryPolicy {
    maxAttempts: number;
    initialInterval: number;
    randomizationFactor: number;
    multiplier: number;
    maxInterval: number;
}
export type DeferableFunction = (...args: any[]) => Promise<any>;
export interface ExecutionOptions {
    delay?: Duration | Date;
    metadata?: ExecutionMetadata;
    discardAfter?: Duration | Date;
}
export interface DeferredFunction<F extends DeferableFunction> {
    (...args: Parameters<F>): Promise<EnqueueResult>;
    __metadata: Manifest;
    __fn: F;
    __execOptions?: ExecutionOptions;
}
export interface DeferredFunctionConfiguration {
    retry?: boolean | number | Partial<RetryPolicy>;
    concurrency?: number;
    maxDuration?: number;
    maxConcurrencyAction?: "keep" | "cancel";
}
/**
 * Define a deferred function
 * @template F
 * @param {F} fn
 * @param {DeferredFunctionConfiguration=} config
 * @returns {DeferredFunction<F>}
 */
export declare function defer<F extends DeferableFunction>(fn: F, config?: DeferredFunctionConfiguration): DeferredFunction<F>;
export declare namespace defer {
    var cron: <F extends DeferableFunction>(fn: F, cronExpr: string, config?: DeferredFunctionConfiguration | undefined) => DeferredFunction<F>;
}
/**
 * Delay an execution
 * @template F
 * @param {DeferredFunction<F>} fn
 * @param {Duration | Date} delay
 * @deprecated Prefer `assignOptions()` (https://www.defer.run/docs/references/defer-client/assign-options)
 * @returns {DeferredFunction<F>}
 */
export declare function delay<F extends DeferableFunction>(fn: DeferredFunction<F>, delay: Duration | Date): DeferredFunction<F>;
/**
 * Add metadata to an execution
 * @template F
 * @param {DeferredFunction<F>} fn
 * @param {ExecutionMetadata} metadata
 * @deprecated Prefer `assignOptions()` (https://www.defer.run/docs/references/defer-client/assign-options)
 * @returns {DeferredFunction<F>}
 */
export declare function addMetadata<F extends DeferableFunction>(fn: DeferredFunction<F>, metadata: ExecutionMetadata): DeferredFunction<F>;
/**
 * Discard an execution if not started after a given interval
 * @template F
 * @param {DeferredFunction<F>} fn
 * @param {Duration | Date} value
 * @deprecated Prefer `assignOptions()` (https://www.defer.run/docs/references/defer-client/assign-options)
 * @returns {DeferredFunction<F>}
 */
export declare function discardAfter<F extends DeferableFunction>(fn: DeferredFunction<F>, value: Duration | Date): DeferredFunction<F>;
/**
 * Assign execution options to a deferred function
 * @template F
 * @param {DeferredFunction<F>} fn
 * @param {ExecutionOptions} options
 * @returns {DeferredFunction<F>}
 */
export declare function assignOptions<F extends DeferableFunction>(fn: DeferredFunction<F>, options: ExecutionOptions): DeferredFunction<F>;
/**
 * Get an execution
 * @async
 * @param {string} id
 * @throws {ExecutionNotFound} when execution does not exists
 * @throws {DeferError} when error is unknown
 * @returns {Promise<GetExecutionResult>}
 */
export declare function getExecution(id: string): Promise<GetExecutionResult>;
/**
 * Get an execution result
 * @async
 * @template T
 * @param {string} id
 * @throws {ExecutionNotFound} when execution does not exists
 * @throws {ExecutionResultNotAvailableYet} when result is not yet available
 * @throws {ExecutionResultNotAvailable} when there's no result
 * @throws {DeferError} when error is unknown
 * @returns {Promise<T>}
 */
export declare function getExecutionResult<T = any>(id: string): Promise<T>;
/**
 * Cancel an execution
 * @async
 * @param {string} id
 * @param {boolean} force
 * @throws {ExecutionNotFound} when execution does not exists
 * @throws {ExecutionAbortingAlreadyInProgress} when execution is started
 * @throws {ExecutionNotCancellable} when execution cannot be cancelled
 * @throws {DeferError} when error is unknown
 * @returns {Promise<CancelExecutionResult>}
 */
export declare function cancelExecution(id: string, force?: boolean): Promise<CancelExecutionResult>;
/**
 * Reschedule an execution
 * @async
 * @param {string} id
 * @param {Duration | Date | undefined} value
 * @throws {ExecutionNotFound} when execution does not exists
 * @throws {ExecutionNotReschedulable} when execution has started and/or completed.
 * @throws {DeferError} when error is unknown
 * @returns {Promise<RescheduleExecutionResult>}
 */
export declare function rescheduleExecution(id: string, value?: Duration | Date | undefined): Promise<RescheduleExecutionResult>;
/**
 * ReRun an execution
 * @async
 * @param {string} id
 * @throws {ExecutionNotFound} when execution does not exists
 * @throws {DeferError} when error is unknown
 * @returns {Promise<ReRunExecutionResult>}
 */
export declare function reRunExecution(id: string): Promise<ReRunExecutionResult>;
/**
 * List an execution attempts
 * @deprecated Prefer `listExecutionAttempts()` (https://www.defer.run/docs/references/defer-client/list-execution-attempts)
 * @async
 * @param {string} id
 * @throws {ExecutionNotFound} when execution does not exists
 * @throws {DeferError} when error is unknown
 * @returns {Promise<ListExecutionAttemptsResult>}
 */
export declare function getExecutionTries(id: string): Promise<ListExecutionAttemptsResult>;
/**
 * List an execution attempts
 * @async
 * @param {string} id
 * @param {PageRequest=} page
 * @param {ExecutionFilters=} filters
 * @throws {ExecutionNotFound} when execution does not exists
 * @throws {DeferError} when error is unknown
 * @returns {Promise<ListExecutionAttemptsResult>}
 */
export declare function listExecutionAttempts(id: string, page?: PageRequest, filters?: ExecutionFilters): Promise<ListExecutionAttemptsResult>;
/**
 * List executions
 * @async
 * @param {PageRequest=} page
 * @param {ExecutionFilters=} filters
 * @throws {DeferError} when error is unknown
 * @returns {Promise<ListExecutionsResult>}
 */
export declare function listExecutions(page?: PageRequest, filters?: ExecutionFilters): Promise<ListExecutionsResult>;
/**
 * Enqueue and wait for an execution result
 * @async
 * @template F
 * @param {DeferredFunction<F>} fn
 * @throws {ExecutionNotFound} when execution does not exists
 * @throws {ExecutionResultNotAvailableYet} when result is not yet available
 * @throws {ExecutionResultNotAvailable} when there's no result
 * @throws {DeferError} when error is unknown
 * @returns {Promise<Awaited<F>>}
 */
export declare function awaitResult<F extends DeferableFunction, R = ReturnType<F>>(fn: DeferredFunction<F>): (...args: Parameters<F>) => Promise<Awaited<R>>;