export type ScheduledTaskType = 'cron' | 'once' | 'interval';
export type ScheduledTaskStatus = 'success' | 'error' | 'running';
export type ScheduledTaskModelConfig = {
    provider: string;
    model: string;
    thinkingLevel?: 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
    authProfileId?: string;
    reasoning?: boolean;
};
export type ScheduledTaskRunHistoryEntry = {
    id: string;
    status: ScheduledTaskStatus | 'paused' | 'resumed';
    createdAt: string;
    sessionId?: string;
    message?: string;
};
export type ScheduledTaskRunContext = {
    historyEntryId: string;
    sessionId: string;
    startedAt: string;
};
export type ScheduledTask = {
    id: string;
    tenantId?: string;
    userId?: string;
    workspaceId?: string;
    sessionId: string;
    name?: string;
    prompt: string;
    type: ScheduledTaskType;
    schedule: string;
    intervalSeconds: number;
    enabled: boolean;
    model: ScheduledTaskModelConfig;
    toolPolicyProfile: string;
    workspaceDir?: string;
    description?: string;
    createdAt: string;
    updatedAt: string;
    lastRunAt?: string;
    nextRunAt?: string;
    runCount: number;
    timeoutMs?: number;
    lastStatus?: ScheduledTaskStatus;
    lastError?: string;
    runHistory?: ScheduledTaskRunHistoryEntry[];
};
export type ScheduledTaskCreateInput = Omit<ScheduledTask, 'id' | 'createdAt' | 'updatedAt' | 'nextRunAt' | 'runCount' | 'lastStatus' | 'lastRunAt' | 'lastError' | 'runHistory'>;
export type ScheduledTaskUpdate = Partial<Omit<ScheduledTask, 'id' | 'tenantId' | 'userId' | 'workspaceId' | 'createdAt' | 'updatedAt' | 'lastRunAt' | 'lastError' | 'nextRunAt' | 'runCount' | 'lastStatus' | 'runHistory' | 'name' | 'description' | 'workspaceDir'>> & {
    name?: string | undefined;
    description?: string | undefined;
    workspaceDir?: string | undefined;
};
export type TaskSchedulerStatus = {
    active: boolean;
    pid: number;
    taskCount: number;
    scheduledTimerCount: number;
    scheduledCronCount: number;
    runningTaskIds: string[];
    lock: {
        path: string;
        acquired: boolean;
        holderPid?: number;
    };
};
export type TaskSchedulerScope = {
    tenantId?: string;
    userId?: string;
};
export interface TaskScheduler {
    list(scope?: TaskSchedulerScope): Promise<ScheduledTask[]>;
    get(taskId: string, scope?: TaskSchedulerScope): Promise<ScheduledTask | undefined>;
    status(): Promise<TaskSchedulerStatus>;
    isActive(): boolean;
    create(input: ScheduledTaskCreateInput): Promise<ScheduledTask>;
    update(taskId: string, input: ScheduledTaskUpdate, scope?: TaskSchedulerScope): Promise<ScheduledTask | undefined>;
    delete(taskId: string, scope?: TaskSchedulerScope): Promise<boolean>;
    runNow(taskId: string, scope?: TaskSchedulerScope): Promise<ScheduledTask | undefined>;
    start(): Promise<void>;
    stop(): Promise<void>;
}
export interface ScheduledTaskStore {
    list(scope?: TaskSchedulerScope): Promise<ScheduledTask[]>;
    get(taskId: string, scope?: TaskSchedulerScope): Promise<ScheduledTask | undefined>;
    create(task: ScheduledTask): Promise<ScheduledTask>;
    update(taskId: string, task: ScheduledTask, scope?: TaskSchedulerScope): Promise<ScheduledTask | undefined>;
    delete(taskId: string, scope?: TaskSchedulerScope): Promise<boolean>;
}
export interface SchedulerLock {
    readonly path: string;
    acquire(): boolean | Promise<boolean>;
    release(): void | Promise<void>;
    isAcquired(): boolean;
    holderPid(): number | undefined | Promise<number | undefined>;
    extend?(): boolean | Promise<boolean>;
}
export type ScheduledTaskRunner = (task: ScheduledTask, run: ScheduledTaskRunContext) => Promise<void>;
export type TaskSchedulerRunEvent = {
    task: ScheduledTask;
    run: ScheduledTaskRunContext;
    timestamp: string;
};
export type TaskSchedulerFailureEvent = TaskSchedulerRunEvent & {
    error: string;
};
export type TaskSchedulerLifecycleEvent = {
    timestamp: string;
    status: TaskSchedulerStatus;
};
export type TaskSchedulerHooks = {
    onTaskStarted?: (event: TaskSchedulerRunEvent) => void | Promise<void>;
    onTaskCompleted?: (event: TaskSchedulerRunEvent) => void | Promise<void>;
    onTaskFailed?: (event: TaskSchedulerFailureEvent) => void | Promise<void>;
    onSchedulerStarted?: (event: TaskSchedulerLifecycleEvent) => void | Promise<void>;
    onSchedulerStopped?: (event: TaskSchedulerLifecycleEvent) => void | Promise<void>;
};
export type PersistentTaskSchedulerOptions = {
    store: ScheduledTaskStore;
    lock: SchedulerLock;
    runner: ScheduledTaskRunner;
    hooks?: TaskSchedulerHooks;
    lockHeartbeatMs?: number;
};
export declare class PersistentTaskScheduler implements TaskScheduler {
    private readonly options;
    private readonly timers;
    private readonly crons;
    private readonly runningTaskIds;
    private active;
    private lockHeartbeat;
    constructor(options: PersistentTaskSchedulerOptions);
    list(scope?: TaskSchedulerScope): Promise<ScheduledTask[]>;
    get(taskId: string, scope?: TaskSchedulerScope): Promise<ScheduledTask | undefined>;
    status(): Promise<TaskSchedulerStatus>;
    isActive(): boolean;
    create(input: ScheduledTaskCreateInput): Promise<ScheduledTask>;
    update(taskId: string, input: ScheduledTaskUpdate, scope?: TaskSchedulerScope): Promise<ScheduledTask | undefined>;
    delete(taskId: string, scope?: TaskSchedulerScope): Promise<boolean>;
    runNow(taskId: string, scope?: TaskSchedulerScope): Promise<ScheduledTask | undefined>;
    start(): Promise<void>;
    stop(): Promise<void>;
    private schedule;
    private execute;
    private unschedule;
    private refreshNextRun;
    private markScheduleError;
    private startLockHeartbeat;
    private emitSchedulerStarted;
    private emitSchedulerStopped;
    private emitHook;
}
export declare function resolveScheduledTaskDefinition(input: {
    type?: ScheduledTaskType;
    schedule?: string;
}): Pick<ScheduledTask, 'type' | 'schedule' | 'intervalSeconds'>;
export declare function normalizeScheduledTask(rawTask: ScheduledTask): ScheduledTask;
export declare function computeNextRunAt(task: ScheduledTask): string | undefined;
export declare function createTaskHistoryEntry(status: ScheduledTaskRunHistoryEntry['status'], message?: string, options?: {
    createdAt?: string;
    sessionId?: string;
}): ScheduledTaskRunHistoryEntry;
export declare function appendTaskHistory(history: ScheduledTaskRunHistoryEntry[] | undefined, entry: ScheduledTaskRunHistoryEntry): ScheduledTaskRunHistoryEntry[];
export declare function updateTaskHistoryEntry(history: ScheduledTaskRunHistoryEntry[] | undefined, entryId: string, patch: Pick<ScheduledTaskRunHistoryEntry, 'status'> & Pick<Partial<ScheduledTaskRunHistoryEntry>, 'message'>): ScheduledTaskRunHistoryEntry[];
export declare function createScheduledTaskRunSessionId(): string;
export declare function scheduleExpressionForCroner(value: string): string;
export { default } from './extension.js';
export { FileSchedulerLock, JsonScheduledTaskStore } from './stores.js';
export { createSchedulerTools } from './tools.js';
//# sourceMappingURL=index.d.ts.map