import type { BulkOptions, JobOptions, JobPayload, JobSetterOptions } from "./types.js";
export type JobConstructor<TArgs extends unknown[] = unknown[]> = {
    new (): Job<TArgs>;
    name: string;
    sidekiqOptions?: JobOptions;
    sidekiqRetryIn?: RetryInHandler;
    sidekiqRetriesExhausted?: RetriesExhaustedHandler;
    getSidekiqOptions(): JobOptions;
    setSidekiqOptions(options: JobOptions): void;
    queueAs(queue: string): void;
    retryIn(handler: RetryInHandler): void;
    retriesExhausted(handler: RetriesExhaustedHandler): void;
    set(options: JobSetterOptions): JobSetter<TArgs>;
    performAsync(...args: TArgs): Promise<string | null>;
    performIn(interval: number, ...args: TArgs): Promise<string | null>;
    performAt(timestamp: number, ...args: TArgs): Promise<string | null>;
    performBulk(args: TArgs[], options?: BulkOptions): Promise<(string | null)[]>;
    performInline(...args: TArgs): Promise<boolean | null>;
    jobs(): JobPayload[];
    clear(): void;
    drain(): Promise<void>;
    performOne(): Promise<void>;
    processJob(payload: JobPayload): Promise<void>;
    clientPush(item: JobPayload): Promise<string | null>;
};
type JobClass = abstract new () => Job<any>;
type JobArgsFromClass<T> = T extends {
    new (): Job<infer TArgs>;
} ? TArgs : unknown[];
export declare abstract class Job<TArgs extends unknown[] = unknown[]> {
    jid?: string;
    _context?: {
        stopping: () => boolean;
        signal?: AbortSignal;
    };
    static getSidekiqOptions(this: JobConstructor): JobOptions;
    static setSidekiqOptions(this: JobConstructor, options: JobOptions): void;
    static queueAs(this: JobConstructor, queue: string): void;
    static retryIn(this: JobConstructor, handler: RetryInHandler): void;
    static retriesExhausted(this: JobConstructor, handler: RetriesExhaustedHandler): void;
    static set<TClass extends JobClass>(this: TClass, options: JobSetterOptions): JobSetter<JobArgsFromClass<TClass>>;
    static performAsync<TClass extends JobClass>(this: TClass, ...args: JobArgsFromClass<TClass>): Promise<string | null>;
    static performIn<TClass extends JobClass>(this: TClass, interval: number, ...args: JobArgsFromClass<TClass>): Promise<string | null>;
    static performAt<TClass extends JobClass>(this: TClass, timestamp: number, ...args: JobArgsFromClass<TClass>): Promise<string | null>;
    static performBulk<TClass extends JobClass>(this: TClass, args: JobArgsFromClass<TClass>[], options?: BulkOptions): Promise<(string | null)[]>;
    static performInline<TClass extends JobClass>(this: TClass, ...args: JobArgsFromClass<TClass>): Promise<boolean | null>;
    static jobs(this: JobConstructor | typeof Job): JobPayload[];
    static clear(this: JobConstructor): void;
    static drain(this: JobConstructor): Promise<void>;
    static performOne(this: JobConstructor): Promise<void>;
    static processJob(this: JobConstructor, payload: JobPayload): Promise<void>;
    static clearAll(): void;
    static drainAll(): Promise<void>;
    static clientPush(this: JobConstructor, item: JobPayload): Promise<string | null>;
    logger(): import("./logger.js").Logger;
    interrupted(): boolean;
    /**
     * Get the AbortSignal for this job.
     * Can be used with fetch(), streams, or any AbortSignal-compatible API.
     * The signal is aborted when the runner is shutting down.
     */
    get signal(): AbortSignal | undefined;
    abstract perform(...args: TArgs): Promise<void> | void;
}
export type RetryInHandler = (count: number, error: Error, payload: JobPayload) => number | "discard" | "kill" | "default";
export type RetriesExhaustedHandler = (payload: JobPayload, error: Error) => "discard" | undefined;
export declare class JobSetter<TArgs extends unknown[] = unknown[]> {
    private readonly klass;
    private options;
    constructor(klass: JobConstructor<TArgs>, options: JobSetterOptions);
    set(options: JobSetterOptions): JobSetter<TArgs>;
    performAsync(...args: TArgs): Promise<string | null>;
    performInline(...args: TArgs): Promise<boolean | null>;
    performBulk(args: TArgs[], options?: BulkOptions): Promise<(string | null)[]>;
    performIn(interval: number, ...args: TArgs): Promise<string | null>;
    performAt(timestamp: number, ...args: TArgs): Promise<string | null>;
    private at;
}
export {};
//# sourceMappingURL=job.d.ts.map