import { FSWatcher } from 'fs';
import { ScheduleRepo, SCHEDULES_FILE, type ScheduleTask } from '../../store/schedule-repo.js';
export type { ScheduleTask } from '../../store/schedule-repo.js';
declare function parseDuration(str: string | null | undefined): number | null;
declare function formatDuration(ms: number): string;
declare function formatTimeUntil(ms: number): string;
interface RunnerParams {
    message: string;
    projectId: string;
    scheduleTaskId: string;
    profileName: string;
    /** Where the fired task should land — passed through so scheduled-task.ts can pick its dispatch branch. */
    target?: ScheduleTask['target'];
    /** What to do if the chosen target thread no longer exists at fire time. */
    fallback?: ScheduleTask['fallback'];
}
interface TaskDispatchParams {
    channel: string;
    scheduleTaskId: string;
    profileName: string;
}
interface ProgrammaticHandlerParams {
    channel: string;
    scheduleTaskId: string;
}
type RunnerFn = (params: RunnerParams) => Promise<void>;
type TaskDispatchRunnerFn = (params: TaskDispatchParams) => Promise<void>;
type ProgrammaticHandler = (params: ProgrammaticHandlerParams) => Promise<void>;
interface SchedulerOptions {
    schedulesFile?: string;
    watchFile?: boolean;
    /** Override the default scheduleRepo (for tests with custom schedulesFile). */
    repo?: ScheduleRepo;
}
declare class Scheduler {
    runner: RunnerFn;
    taskDispatchRunner: TaskDispatchRunnerFn | null;
    programmaticHandlers: Record<string, ProgrammaticHandler>;
    schedulesFile: string;
    watchFile: boolean;
    timers: Map<string, ReturnType<typeof setTimeout>>;
    _repo: ScheduleRepo;
    _inFlight: Set<string>;
    _taskConfigs: Map<string, string>;
    _watcher: FSWatcher | null;
    _reloadTimer: ReturnType<typeof setTimeout> | null;
    _selfWriting: boolean;
    _beforeRunGuard: ((task: ScheduleTask) => boolean) | null;
    /** Async callback invoked after _beforeRunGuard blocks a task. Used for async bookkeeping (e.g. persisting pause). */
    _onGuardBlocked: ((task: ScheduleTask) => Promise<void>) | null;
    /** Admin notification callback for hot-reload → Slack messages. Set by app.ts after adapter creation. */
    _adminNotifier: ((text: string) => void) | null;
    /** Set _selfWriting=true before a disk write, clear after 100ms to avoid triggering fs.watch hot-reload. */
    _withWriteGuard<T>(fn: () => Promise<T>): Promise<T>;
    constructor(runner: RunnerFn, taskDispatchRunner: TaskDispatchRunnerFn | null, programmaticHandlers?: Record<string, ProgrammaticHandler>, options?: SchedulerOptions);
    /** Set a callback for admin notifications (hot-reload → Slack). Called by app.ts after adapter creation. */
    setAdminNotifier(fn: (text: string) => void): void;
    start(): Promise<void>;
    stop(): void;
    _startWatching(): void;
    _hotReload(): Promise<void>;
    add(type: string, options: Record<string, any>): Promise<ScheduleTask>;
    remove(id: string): Promise<boolean>;
    list(): Promise<ScheduleTask[]>;
    get(id: string): Promise<ScheduleTask | null>;
    update(id: string, patch: Record<string, any>): Promise<ScheduleTask | null>;
    pause(id: string, pausedBy?: 'user' | 'rate-limit'): Promise<ScheduleTask | null>;
    resume(id: string): Promise<ScheduleTask | null>;
    setBeforeRunGuard(fn: ((task: ScheduleTask) => boolean) | null): void;
    setOnGuardBlocked(fn: ((task: ScheduleTask) => Promise<void>) | null): void;
    getRateLimitThrottle(): Promise<{
        resetsAt: number;
        activatedAt: number;
        modes?: string[];
    } | null>;
    setRateLimitThrottle(meta: {
        resetsAt: number;
        activatedAt: number;
        modes?: string[];
    } | null): Promise<void>;
    setInterval(id: string, intervalMs: number): Promise<ScheduleTask | null>;
    _rescheduleTask(task: ScheduleTask): void;
    _scheduleTask(task: ScheduleTask): void;
    _runTask(task: ScheduleTask): Promise<void>;
}
export { Scheduler, parseDuration, formatDuration, formatTimeUntil, SCHEDULES_FILE };