import { DatabaseConfig } from '@n8n/config';
import { DataSource, type EntityManager, Repository } from '@n8n/typeorm';
import { ScheduledTask, type TerminalTaskStatus } from '../entities/scheduled-task';
export interface ClaimDueTasksOptions {
    host: string;
    taskTypes: string[];
    lookaheadMs: number;
    leaseMs: number;
    batchSize: number;
}
export interface ClaimedRef {
    id: string;
    claimedEpoch: number;
}
export interface HostedClaimedRef extends ClaimedRef {
    host: string;
}
export interface DeleteFinishedTasksOptions {
    statuses: TerminalTaskStatus[];
    olderThanMs: number;
    limit: number;
}
export interface NewOccurrence {
    jobId: number;
    taskType: string;
    payload: Record<string, unknown>;
    scheduledFor: Date;
    runAt: Date;
    maxAttempts: number;
    timeoutSeconds: number;
    missedAfter?: Date | null;
}
export interface RetiredTask {
    id: string;
    jobId: number;
    taskType: string;
}
export interface RetireMissedResult {
    retired: number;
    heldByConcurrencyLimit: RetiredTask[];
}
export interface RecordedOccurrence {
    id: string;
    jobId: number;
    taskType: string;
}
export interface InsertOccurrencesResult {
    recorded: number;
    created: RecordedOccurrence[];
}
export type ScheduledTaskMetricSnapshot = {
    pending: number;
    due: number;
    running: number;
    oldestPendingAgeMs: number | null;
};
export declare class ScheduledTaskRepository extends Repository<ScheduledTask> {
    private readonly isPostgres;
    private readonly tableName;
    private readonly jobTableName;
    private readonly leaseExpiresAtColumn;
    private readonly dispatchedAtColumn;
    private readonly runAtColumn;
    private readonly missedAfterColumn;
    constructor(dataSource: DataSource, config: DatabaseConfig);
    insertIgnoringDuplicates(manager: EntityManager, occurrences: NewOccurrence[], chunkSize?: number): Promise<InsertOccurrencesResult>;
    deletePendingByJobIds(manager: EntityManager, jobIds: number[]): Promise<void>;
    updateToMissed(manager: EntityManager, superseded: Array<{
        jobId: number;
        before: Date;
    }>): Promise<number>;
    updateTimeoutForPendingJobs(manager: EntityManager, jobIds: number[], timeoutSeconds: number): Promise<void>;
    updateMissedAfterForJobs(manager: EntityManager, jobIds: number[], misfireGraceSeconds: number): Promise<void>;
    claimDueTasks(opts: ClaimDueTasksOptions): Promise<ScheduledTask[]>;
    private claimCandidateSql;
    private limitedJobIdsSql;
    private withinConcurrencyLimitSql;
    private allowedByConcurrencyLimitSql;
    private claimableSql;
    private claimWithPostgres;
    private claimWithSqlite;
    beginDispatch(claim: HostedClaimedRef, leaseMs: number): Promise<number>;
    renewLease(claim: HostedClaimedRef, expiresInMs: number): Promise<boolean>;
    markDispatched(claim: HostedClaimedRef): Promise<number>;
    completeTask(claim: HostedClaimedRef): Promise<number>;
    failTaskTerminal(claim: HostedClaimedRef, errorMessage: string): Promise<number>;
    rescheduleTask(claim: HostedClaimedRef, backoffMs: number, errorMessage: string): Promise<number>;
    releaseClaim(claim: HostedClaimedRef): Promise<number>;
    findExpiredLeases(limit: number): Promise<ScheduledTask[]>;
    getMetricSnapshot(): Promise<ScheduledTaskMetricSnapshot>;
    readDbTime(manager?: EntityManager): Promise<Date>;
    reclaimExpired(ref: ClaimedRef, backoffMs: number, errorMessage: string): Promise<number>;
    deadLetterExpired(ref: ClaimedRef, errorMessage: string): Promise<number>;
    completeExpired(ref: ClaimedRef): Promise<number>;
    private runGuardedUpdate;
    private runReaperUpdate;
    deleteFinishedOlderThan(options: DeleteFinishedTasksOptions): Promise<number>;
    private deleteFinishedWithPostgres;
    private deleteFinishedWithSqlite;
    retireMissedPending(limit: number): Promise<RetireMissedResult>;
    private atConcurrencyLimitSql;
    private staleSql;
    private retireMissedPendingWithPostgres;
    private retireMissedPendingWithSqlite;
}