/// <reference types="node" />
import { Job } from 'node-schedule';
import { Locker } from './interfaces/locker.interface';
import { TimeoutOptions } from './interfaces/timeout-options.interface';
import { IntervalOptions } from './interfaces/interval-options.interface';
import { CronObject, CronObjLiteral, CronOptions } from './interfaces/cron-options.interface';
interface TargetHost {
    target: Function;
}
interface IntervalHost {
    interval: number;
    locker?: Locker;
    options?: IntervalOptions;
}
interface TimeoutHost {
    timeout: number;
    locker?: Locker;
    options?: TimeoutOptions;
}
interface RefHost<T> {
    ref?: T;
}
interface CronHost {
    rule: string | number | Date | CronObject | CronObjLiteral;
    locker?: Locker;
    options?: CronOptions;
    job?: Job;
}
export declare type IntervalJobOptions = TargetHost & IntervalHost & RefHost<NodeJS.Timeout>;
export declare type TimeoutJobOptions = TargetHost & TimeoutHost & RefHost<NodeJS.Timeout>;
export declare type CronJobOptions = TargetHost & CronHost & RefHost<Job>;
export declare class SchedulerRegistry {
    private readonly cronJobs;
    private readonly timeoutJobs;
    private readonly intervalJobs;
    getCronJob(name: string): CronJobOptions | undefined;
    getIntervalJob(name: string): IntervalJobOptions | undefined;
    getTimeoutJob(name: string): TimeoutJobOptions | undefined;
    addCronJob(name: string, cronJob: CronJobOptions): void;
    addIntervalJob(name: string, intervalJob: IntervalJobOptions): void;
    addTimeoutJob(name: string, timeoutJob: TimeoutJobOptions): void;
    getCronJobs(): Map<string, CronJobOptions>;
    deleteCronJob(name: string): void;
    getIntervalJobs(): Map<string, IntervalJobOptions>;
    deleteIntervalJob(name: string): void;
    getTimeoutJobs(): Map<string, TimeoutJobOptions>;
    deleteTimeoutJob(name: string): void;
}
export {};