import { TCronExecuteResult, TCronPollingTime, TDiscard, TThreadChild } from '../../../../../types/index';
/**
 * 调度服务接口
 *
 * 记得实现 @TaskRegister装饰器修饰的类，否则不会被扫描到
 *
 * @example
 * ```typescript
 * @TaskCronService
 * class TestCronTaskService extends ICronTaskService {
 *   NAME: string = 'TestCronTaskService';
 *   CRON_EXP: string = '*\/10 * * * * *';
 *   async collection(): Promise<void> {
 *     Array.from({ length: 3 }, (_, i) => `测试定时任务${i + 1}`).forEach((name, i) => {
 *       this.addPending(i + 1, name);
 *     });
 *   }
 *   async execute(task: TThreadChild<any>): Promise<TCronExecuteResult<any>> {
 *     return { task, success: true };
 *   }
 *   override async executeEnd(data: any): Promise<void> {
 *     Logger.info(data.task, data.success);
 *   }
 * }
 * ```
 */
export declare abstract class ICronTaskService<T = any> {
    NAME: string;
    DESCRIPTION: string;
    CRON_EXP: string;
    WAIT_TIME: TCronPollingTime;
    DISCARD: TDiscard;
    private _queuePending;
    private _queueReady;
    private _queueRunning;
    private _runLock;
    private _plusLock;
    private QUEUE_MAX;
    /**
     * 初始化调度器
     * @param name 调度器名称
     * @param description 调度器描述
     * @param cronExp 调度器表达式
     */
    init(name: string, description: string, cronExp: string): void;
    run(): Promise<void>;
    /**
     * 使用 addPending 方法收集任务对象并挂起线程
     *
     * 比如：这个调度任务是自动签到，就是把需要签到的用户对象收集起来，然后挂起线程，等待执行。
     *
     * 主要注意：调用 addPending 方法传入的任务ID唯一
     *
     * @example
     * ```typescript
     * async collection(): Promise<void> {
     *   Array.from({ length: 3 }, (_, i) => `测试定时任务${i + 1}`).forEach((name, i) => {
     *     this.addPending(i + 1, name);
     *   });
     * }
     * ```
     */
    abstract collection(): Promise<void>;
    /**
     * 添加调度任务
     * @param key 键
     * @param value 值
     * @param update 是否强制更新已经存在的任务
     */
    protected addPending(key: any, value: T, update?: boolean): void;
    /**
     * 移除调度任务
     * @param key 键
     */
    protected removePending(key: any): void;
    /**
     * 增加线程
     * 增加线程时，会先上锁，然后将挂起的任务全部加入到线程队列中
     */
    protected plusThread(): void;
    /**
     * 激活线程
     * 将挂起的任务全部加入到线程队列中
     * 线程未激活则先上锁，再激活线程，防止多次激活
     */
    protected activeThread(): void;
    /**
     * 执行所有任务
     * 循环执行所有任务，直到所有任务执行完毕
     */
    protected executeAll(): Promise<void>;
    /**
     * 实际执行任务
     *
     * 收到的参数 task 是 TThreadChild<T> 类型，{key: any, value: T} 的形式
     *
     * key、value是你在 collection 方法中传入的任务ID和任务对象
     *
     * @param task 任务键值对
     * @example
     * ```typescript
     * async execute(task: TThreadChild<any>): Promise<TCronExecuteResult<any>> {
     *   const { key, value } = task;
     *   // 执行任务
     *   const result: boolean = await xxxService.doSomething(value);
     *   return { task, success: result };
     * }
     * ```
     */
    abstract execute(task: TThreadChild<T>): Promise<TCronExecuteResult<T>>;
    /**
     * 任务执行结束后，会调用此方法，你可以在此方法中处理任务执行结果
     *
     * 如果不需要处理结果，可以空实现
     * @param result {TCronExecuteResult} 任务执行结果
     * @example
     * ```typescript
     * async executeEnd(data: any): Promise<void> {
     *   const { task, success } = data;
     *   if (success) {
     *     Logger.info(`任务${task.key}执行成功`);
     *   } else {
     *     Logger.error(`任务${task.key}执行失败`);
     *   }
     *   xxxService.saveResult(task.value, success);
     * }
     * ```
     */
    abstract executeEnd(result: TCronExecuteResult<T>): Promise<void>;
}