/**
 * FlashQ Client - High-performance job queue client.
 *
 * This is the main facade that exposes all operations.
 * Methods are organized into logical modules under ./methods/
 */
import { FlashQConnection } from './connection';
import { type ClientHooks } from '../hooks';
import type { Job, JobState, JobWithState, PushOptions, QueueInfo, QueueStats, Metrics, CronJob, CronOptions, JobLogEntry, FlowChild, FlowResult, FlowOptions, BatchPushResult } from './types';
export type { BatchPushResult } from './types';
/** FlashQ Client - High-performance job queue client with auto-connect. */
export declare class FlashQ extends FlashQConnection {
    /** Hooks for observability */
    get hooks(): ClientHooks | undefined;
    /** Push a job to a queue */
    push<T = unknown>(queueName: string, data: T, opts?: PushOptions): Promise<Job>;
    /** Add a job to a queue (alias for push) */
    add<T = unknown>(queueName: string, data: T, opts?: PushOptions): Promise<Job>;
    /** Push multiple jobs in a single batch */
    pushBatch<T = unknown>(queueName: string, jobList: Array<{
        data: T;
    } & PushOptions>): Promise<number[]>;
    /** Add multiple jobs (alias for pushBatch) */
    addBulk<T = unknown>(queueName: string, jobList: Array<{
        data: T;
    } & PushOptions>): Promise<number[]>;
    /** Push multiple jobs with partial failure handling */
    pushBatchSafe<T = unknown>(queueName: string, jobList: Array<{
        data: T;
    } & PushOptions>): Promise<BatchPushResult>;
    /** Pull a job from a queue (blocking with timeout) */
    pull<T = unknown>(queueName: string, timeout?: number): Promise<(Job & {
        data: T;
    }) | null>;
    /** Pull multiple jobs from a queue */
    pullBatch<T = unknown>(queueName: string, count: number, timeout?: number): Promise<Array<Job & {
        data: T;
    }>>;
    /** Acknowledge a job as completed */
    ack(jobId: number, result?: unknown): Promise<void>;
    /** Acknowledge multiple jobs at once */
    ackBatch(jobIds: number[]): Promise<number>;
    /** Fail a job (will retry or move to DLQ) */
    fail(jobId: number, error?: string): Promise<void>;
    /** Get a job with its current state */
    getJob(jobId: number): Promise<JobWithState | null>;
    /** Get job state only */
    getState(jobId: number): Promise<JobState | null>;
    /** Get job result */
    getResult<T = unknown>(jobId: number): Promise<T | null>;
    /** Wait for a job to complete (finished() promise pattern) */
    finished<T = unknown>(jobId: number, timeout?: number): Promise<T | null>;
    /** Get a job by its custom ID */
    getJobByCustomId(customId: string): Promise<JobWithState | null>;
    /** Get multiple jobs by their IDs */
    getJobsBatch(jobIds: number[]): Promise<JobWithState[]>;
    /** Cancel a pending job */
    cancel(jobId: number): Promise<void>;
    /** Update job progress */
    progress(jobId: number, value: number, message?: string): Promise<void>;
    /** Get job progress */
    getProgress(jobId: number): Promise<{
        progress: number;
        message?: string;
    }>;
    /** Add a log entry to a job */
    log(jobId: number, message: string, level?: 'info' | 'warn' | 'error'): Promise<void>;
    /** Get log entries for a job */
    getLogs(jobId: number): Promise<JobLogEntry[]>;
    /** Send a heartbeat for a long-running job */
    heartbeat(jobId: number): Promise<void>;
    /** Send partial result for streaming jobs (LLM tokens, chunks, etc.) */
    partial(jobId: number, data: unknown, index?: number): Promise<void>;
    /** Pause a queue */
    pause(queueName: string): Promise<void>;
    /** Resume a paused queue */
    resume(queueName: string): Promise<void>;
    /** Check if a queue is paused */
    isPaused(queueName: string): Promise<boolean>;
    /** Set rate limit for a queue (jobs per second) */
    setRateLimit(queueName: string, limit: number): Promise<void>;
    /** Clear rate limit for a queue */
    clearRateLimit(queueName: string): Promise<void>;
    /** Set concurrency limit for a queue */
    setConcurrency(queueName: string, limit: number): Promise<void>;
    /** Clear concurrency limit for a queue */
    clearConcurrency(queueName: string): Promise<void>;
    /** List all queues */
    listQueues(): Promise<QueueInfo[]>;
    /** Get jobs from the dead letter queue */
    getDlq(queueName: string, count?: number): Promise<Job[]>;
    /** Retry jobs from the dead letter queue */
    retryDlq(queueName: string, jobId?: number): Promise<number>;
    /** Purge all jobs from the dead letter queue */
    purgeDlq(queueName: string): Promise<number>;
    /** Add a cron job for scheduled recurring tasks */
    addCron(name: string, options: CronOptions): Promise<void>;
    /** Delete a cron job */
    deleteCron(name: string): Promise<boolean>;
    /** List all cron jobs */
    listCrons(): Promise<CronJob[]>;
    /** Get queue statistics */
    stats(): Promise<QueueStats>;
    /** Get detailed metrics */
    metrics(): Promise<Metrics>;
    /** Push a flow (parent job with children) */
    pushFlow<T = unknown>(queueName: string, parentData: T, children: FlowChild[], options?: FlowOptions): Promise<FlowResult>;
    /** Get children job IDs for a parent job */
    getChildren(jobId: number): Promise<number[]>;
    /** Get jobs filtered by queue and/or state with pagination */
    getJobs(options?: {
        queue?: string;
        state?: JobState;
        limit?: number;
        offset?: number;
    }): Promise<{
        jobs: JobWithState[];
        total: number;
    }>;
    /** Get job counts by state for a queue */
    getJobCounts(queueName: string): Promise<{
        waiting: number;
        active: number;
        delayed: number;
        completed: number;
        failed: number;
    }>;
    /** Get total count of jobs in a queue (waiting + delayed) */
    count(queueName: string): Promise<number>;
    /** Clean jobs older than grace period by state */
    clean(queueName: string, grace: number, state: 'waiting' | 'delayed' | 'completed' | 'failed', limit?: number): Promise<number>;
    /** Drain all waiting jobs from a queue */
    drain(queueName: string): Promise<number>;
    /** Remove ALL data for a queue */
    obliterate(queueName: string): Promise<number>;
    /** Change job priority */
    changePriority(jobId: number, priority: number): Promise<void>;
    /** Move job from processing back to delayed */
    moveToDelayed(jobId: number, delay: number): Promise<void>;
    /** Promote delayed job to waiting immediately */
    promote(jobId: number): Promise<void>;
    /** Update job data */
    update<T = unknown>(jobId: number, data: T): Promise<void>;
    /** Discard job - move directly to DLQ */
    discard(jobId: number): Promise<void>;
    /** Subscribe to real-time events via SSE */
    subscribe(queueName?: string): import('../events').EventSubscriber;
    /** Subscribe to real-time events via WebSocket */
    subscribeWs(queueName?: string): import('../events').EventSubscriber;
}
export default FlashQ;
//# sourceMappingURL=index.d.ts.map