import type { RedisInfo } from "redis-info";
export type JobOptions = {
    priority?: number;
    attempts?: number;
    delay?: number;
    lifo?: boolean;
    timeout?: number;
    removeOnComplete?: boolean | number;
    removeOnFail?: boolean | number;
    repeat?: {
        count?: number;
        pattern?: string;
        every?: number;
        limit?: number;
    };
};
export type AdaptedJob = {
    id: string;
    name: string;
    data: Record<string, unknown>;
    opts: JobOptions;
    createdAt: Date;
    processedAt: Date | null;
    finishedAt: Date | null;
    failedReason?: string;
    stacktrace?: string[];
    retriedAt: Date | null;
    returnValue?: unknown;
    groupId?: string;
    progress?: number;
    attemptsMade?: number;
    rawName?: string;
    processedBy?: string;
    attemptsStarted?: number;
    stalledCounter?: number;
    deduplicationId?: string;
    runAt?: Date | null;
    priority?: number;
};
export type JobCounts = Partial<Record<string, number>>;
export type JobTimeRange = {
    from?: number;
    to?: number;
};
export type FinishedRange = {
    offset: number;
    count: number;
};
export type QueueLimits = {
    concurrency: number | null;
    rateLimit: {
        max: number;
        duration: number;
    } | null;
    rateLimitedForMs: number;
};
/** The listed options that are set on `opts`, to carry them to another job. */
export declare const pickJobOptions: (opts: Record<string, unknown> | undefined, keys: readonly string[]) => Record<string, unknown>;
export type JobPageMeta = {
    capped: boolean;
    cursorAdvance?: number;
    exhausted?: boolean;
    scanned: number;
    scanLimit: number;
    truncated?: boolean;
};
export type JobScanToken = symbol;
export type FeatureSupport<SupportedStatus extends string = string> = {
    addJobOptions: boolean;
    addJobOptionKeys: readonly string[];
    jobNames: boolean;
    pause: boolean;
    resume: boolean;
    clean: boolean | {
        supportedStatuses: SupportedStatus[];
    };
    discard: boolean;
    retry: boolean;
    promote: boolean;
    logs: boolean;
    schedulers: boolean;
    schedulerUpdate: boolean;
    flows: boolean;
    priorities: boolean;
    empty: boolean;
    metrics: boolean;
    statuses: SupportedStatus[];
    groups: boolean;
    workers: boolean;
    updateData: boolean;
    changeDelay: boolean;
    changePriority: boolean;
    deduplication: boolean;
    concurrencyLimit: boolean;
    rateLimit: boolean;
};
export type SchedulerInfo = {
    key: string;
    name: string;
    id?: string | null;
    iterationCount?: number;
    limit?: number;
    startDate?: number;
    endDate?: number;
    tz?: string;
    pattern?: string;
    every?: number;
    next?: number;
    offset?: number;
    template?: {
        name?: string;
        data?: Record<string, unknown>;
        opts?: Record<string, unknown>;
    };
};
export declare class UnsupportedSchedulerUpdateError extends Error {
    constructor(message: string);
}
export declare class JobNotFoundError extends Error {
    constructor(message?: string);
}
export type QueueMetrics = {
    data: number[];
    count: number;
    previousCount: number | null;
    coveredMinutes: number;
    meta: {
        count: number;
        prevTS: number;
        prevCount: number;
    };
};
export type FlowParent = {
    queueKey: string;
    id: string;
    failureHandled: boolean;
};
export type FlowChildSet = "processed" | "unprocessed" | "failed" | "ignored";
export type FlowChildren = {
    total: number;
    keys: Array<{
        key: string;
        set: FlowChildSet;
    }>;
};
export type GroupInfo = {
    id: string;
    count: number;
    status: "active" | "paused" | "rate-limited";
};
export type WorkerInfo = {
    id: string;
    name?: string;
    ageSeconds?: number;
    idleSeconds?: number;
};
export declare abstract class QueueAdapter<SupportedStatus extends string = string, CleanableStatus extends SupportedStatus = SupportedStatus> {
    protected displayName: string;
    protected jobNameFn?: (data: Record<string, unknown>) => string;
    constructor(displayName: string, jobNameFn?: (data: Record<string, unknown>) => string);
    abstract getName(): string;
    abstract getType(): "bull" | "bullmq" | "bee" | "groupmq";
    getDisplayName(): string;
    abstract supports: FeatureSupport<SupportedStatus>;
    abstract getJobCounts(): Promise<JobCounts>;
    getFailedCount(): Promise<number>;
    abstract isPaused(): Promise<boolean>;
    abstract pause(): Promise<void>;
    abstract resume(): Promise<void>;
    abstract empty(): Promise<void>;
    abstract clean(status: CleanableStatus, graceMs: number): Promise<void>;
    abstract getRedisInfo(): Promise<RedisInfo & {
        maxclients: string;
    }>;
    abstract getJobs(status: SupportedStatus, start: number, end: number, scanLimit?: number, scanToken?: JobScanToken): Promise<AdaptedJob[]>;
    beginJobScan(_status: SupportedStatus, _scanLimit?: number): JobScanToken | undefined;
    endJobScan(_scanToken: JobScanToken): void;
    getJobPageMeta(_jobs: AdaptedJob[]): JobPageMeta | undefined;
    abstract getJob(jobId: string): Promise<AdaptedJob | null>;
    getJobStatus(jobId: string): Promise<SupportedStatus | null>;
    abstract addJob(data: Record<string, unknown>, opts?: Record<string, unknown>, name?: string): Promise<AdaptedJob>;
    abstract rerunJob(jobId: string): Promise<AdaptedJob>;
    abstract removeJob(jobId: string): Promise<void>;
    abstract retryJob(jobId: string): Promise<void>;
    abstract promoteJob(jobId: string): Promise<void>;
    abstract discardJob(jobId: string): Promise<void>;
    abstract getJobLogs(jobId: string): Promise<string[] | null>;
    getFinishedRange?(status: "completed" | "failed", range: JobTimeRange): Promise<FinishedRange | null>;
    getRunAts?(jobIds: readonly string[]): Promise<Map<string, Date>>;
    updateJobData?(jobId: string, data: Record<string, unknown>): Promise<void>;
    changeJobDelay?(jobId: string, delayMs: number): Promise<void>;
    changeJobPriority?(jobId: string, priority: number): Promise<void>;
    removeJobDeduplication?(jobId: string): Promise<boolean>;
    getLimits?(): Promise<QueueLimits>;
    setConcurrencyLimit?(concurrency: number | null): Promise<void>;
    setRateLimit?(limit: {
        max: number;
        duration: number;
    } | null): Promise<void>;
    clearRateLimit?(): Promise<void>;
    getSchedulers?(): Promise<SchedulerInfo[]>;
    addScheduler?(name: string, opts: Record<string, unknown>, template: Record<string, unknown>): Promise<void>;
    updateScheduler?(key: string, opts: Record<string, unknown>, template: Record<string, unknown>): Promise<boolean>;
    removeScheduler?(key: string): Promise<void>;
    getMetrics?(type: "completed" | "failed", start: number, end: number): Promise<QueueMetrics>;
    getQueueKey?(): string;
    getJobParent?(jobId: string): Promise<FlowParent | null>;
    getJobChildren?(jobId: string, limit: number): Promise<FlowChildren>;
    getGroups(): Promise<GroupInfo[]>;
    getWorkers(): Promise<WorkerInfo[] | null>;
    protected getJobName(data: Record<string, unknown>, fallback: string): string;
    supportsStatus(status: SupportedStatus): boolean;
    canCleanStatus(status: SupportedStatus): status is CleanableStatus;
}
//# sourceMappingURL=base.adapter.d.ts.map