import type { Config } from "./config.js";
import type { JobPayload } from "./types.js";
export declare class Stats {
    private readonly config?;
    constructor(config?: Config);
    processed(): Promise<number>;
    failed(): Promise<number>;
    workersSize(): Promise<number>;
    scheduledSize(): Promise<number>;
    retrySize(): Promise<number>;
    deadSize(): Promise<number>;
    processesSize(): Promise<number>;
    enqueued(): Promise<number>;
    defaultQueueLatency(): Promise<number>;
    reset(...stats: Array<string | number | symbol>): Promise<void>;
    queues(): Promise<Record<string, number>>;
}
export declare class StatsHistory {
    private readonly config?;
    private readonly daysPrevious;
    private readonly startDate;
    constructor(daysPrevious: number, startDate?: Date, config?: Config);
    processed(): Promise<Record<string, number>>;
    failed(): Promise<Record<string, number>>;
    private dateStat;
}
export declare class Queue {
    private readonly config?;
    readonly name: string;
    constructor(name?: string, config?: Config);
    static all(config?: Config): Promise<Queue[]>;
    size(): Promise<number>;
    clear(): Promise<void>;
    entries(start?: number, stop?: number): Promise<JobPayload[]>;
    latency(): Promise<number>;
    each(pageSize?: number): AsyncGenerator<JobRecord>;
    findJob(jid: string): Promise<JobRecord | null>;
}
export declare class JobRecord {
    readonly queue: string;
    readonly value: string;
    readonly payload: JobPayload;
    private readonly config?;
    constructor(value: string, queue: string, config?: Config);
    get jid(): string | undefined;
    delete(): Promise<boolean>;
}
declare class SortedSet {
    protected config?: Config;
    protected key: string;
    constructor(key: string, config?: Config);
    size(): Promise<number>;
    clear(): Promise<void>;
}
export declare class SortedEntry {
    readonly score: number;
    readonly payload: JobPayload;
    readonly value: string;
    private readonly parent;
    constructor(parent: JobSet, score: number, value: string);
    get jid(): string | undefined;
    delete(): Promise<void>;
    reschedule(at: number): Promise<void>;
    addToQueue(): Promise<void>;
    retry(): Promise<void>;
    kill(): Promise<void>;
}
declare class JobSet extends SortedSet {
    entries(start?: number, stop?: number): Promise<SortedEntry[]>;
    scan(match: string, count?: number): AsyncGenerator<SortedEntry>;
    each(): AsyncGenerator<SortedEntry>;
    findJob(jid: string): Promise<SortedEntry | null>;
    schedule(timestamp: number, payload: JobPayload): Promise<void>;
    retryAll(): Promise<void>;
    killAll(): Promise<void>;
    deleteByValue(value: string): Promise<void>;
    rescheduleValue(value: string, at: number): Promise<void>;
    addToQueueValue(value: string): Promise<void>;
    retryValue(value: string): Promise<void>;
    killValue(value: string): Promise<void>;
    private popEach;
}
export declare class ScheduledSet extends JobSet {
    constructor(config?: Config);
}
export declare class RetrySet extends JobSet {
    constructor(config?: Config);
}
export declare class DeadSet extends JobSet {
    constructor(config?: Config);
    kill(payload: string | JobPayload, options?: {
        trim?: boolean;
    }): Promise<void>;
    trim(): Promise<void>;
}
export interface ProcessInfoEntry {
    identity: string;
    info: Record<string, unknown>;
    busy: number;
    beat: number;
    quiet: boolean;
    rtt_us: number;
    rss: number;
}
export declare class ProcessSet {
    private readonly config?;
    constructor(config?: Config);
    static get(identity: string, config?: Config): Promise<ProcessInfoEntry | null>;
    entries(): Promise<ProcessInfoEntry[]>;
    size(): Promise<number>;
    totalConcurrency(): Promise<number>;
    totalRss(): Promise<number>;
    cleanup(): Promise<number>;
}
/**
 * Represents a single Sidekiq process and allows remote signaling.
 */
export declare class Process {
    private readonly config?;
    readonly identity: string;
    readonly info: Record<string, unknown>;
    readonly busy: number;
    readonly beat: number;
    readonly quiet: boolean;
    readonly rtt_us: number;
    readonly rss: number;
    constructor(entry: ProcessInfoEntry, config?: Config);
    get tag(): string | undefined;
    get labels(): string[];
    get queues(): string[];
    get version(): string | undefined;
    get embedded(): boolean;
    /**
     * Whether this process is quiet or shutting down.
     */
    get stopping(): boolean;
    /**
     * Signal this process to stop processing new jobs.
     * It will continue to execute jobs it has already fetched.
     * This method is asynchronous and it can take 5-10 seconds
     * for the process to quiet.
     */
    quietProcess(): Promise<void>;
    /**
     * Signal this process to shutdown.
     * It will shutdown within its configured timeout value, default 25 seconds.
     * This method is asynchronous and it can take 5-10 seconds
     * for the process to start shutting down.
     */
    stopProcess(): Promise<void>;
    /**
     * Signal this process to log its current worker state.
     * Useful for debugging frozen or deadlocked processes.
     * This method is asynchronous and it can take 5-10 seconds.
     */
    dumpThreads(): Promise<void>;
    private signal;
}
export interface WorkerEntry {
    process: string;
    thread: string;
    queue: string;
    payload: JobPayload;
    run_at: number;
}
export declare class Workers {
    private readonly config?;
    constructor(config?: Config);
    entries(): Promise<WorkerEntry[]>;
}
export {};
//# sourceMappingURL=api.d.ts.map