/**
 * SochDB Priority Queue
 *
 * First-class queue API with ordered-key task entries, providing efficient
 * priority queue operations without the O(N) blob rewrite anti-pattern.
 *
 * Features:
 * - Ordered-key representation: Each task has its own key, no blob parsing
 * - O(log N) enqueue/dequeue with ordered scans
 * - Atomic claim protocol for concurrent workers
 * - Visibility timeout for crash recovery
 *
 * @example
 * ```typescript
 * import { Database, PriorityQueue } from '@sochdb/sochdb';
 *
 * const db = await Database.open('./queue_db');
 * const queue = PriorityQueue.fromDatabase(db, 'tasks');
 *
 * // Enqueue task
 * await queue.enqueue(1, Buffer.from('high priority task'));
 *
 * // Dequeue and process
 * const task = await queue.dequeue('worker-1');
 * if (task) {
 *   // Process task...
 *   await queue.ack(task.taskId);
 * }
 * ```
 */
export declare enum TaskState {
    PENDING = "pending",
    CLAIMED = "claimed",
    COMPLETED = "completed",
    DEAD_LETTERED = "dead_lettered"
}
export interface QueueConfig {
    name: string;
    visibilityTimeout?: number;
    maxRetries?: number;
    deadLetterQueue?: string;
}
export interface QueueKey {
    queueId: string;
    priority: number;
    readyTs: number;
    sequence: number;
    taskId: string;
}
export interface Task {
    taskId: string;
    priority: number;
    payload: Buffer;
    state: TaskState;
    enqueuedAt: number;
    claimedAt?: number;
    claimedBy?: string;
    completedAt?: number;
    retries: number;
    metadata?: Record<string, any>;
}
export interface QueueStats {
    pending: number;
    claimed: number;
    completed: number;
    deadLettered: number;
    totalEnqueued: number;
    totalDequeued: number;
}
export declare class PriorityQueue {
    private db;
    private config;
    private static sequenceCounter;
    constructor(db: any, config: QueueConfig);
    /**
     * Create queue from embedded database
     */
    static fromDatabase(db: any, name: string, config?: Partial<QueueConfig>): PriorityQueue;
    /**
     * Create queue from gRPC client
     */
    static fromClient(client: any, name: string, config?: Partial<QueueConfig>): PriorityQueue;
    /**
     * Enqueue a task with priority
     * Lower priority number = higher urgency
     */
    enqueue(priority: number, payload: Buffer, metadata?: Record<string, any>): Promise<string>;
    /**
     * Dequeue the highest priority task
     * Returns null if no tasks available
     */
    dequeue(workerId: string): Promise<Task | null>;
    /**
     * Acknowledge task completion
     */
    ack(taskId: string): Promise<void>;
    /**
     * Negative acknowledge - return task to queue
     */
    nack(taskId: string): Promise<void>;
    /**
     * Get queue statistics
     */
    stats(): Promise<QueueStats>;
    /**
     * Purge completed tasks
     */
    purge(): Promise<number>;
    private generateTaskId;
    private getTask;
    private updateTask;
    private getStat;
    private incrementStat;
    private decrementStat;
}
/**
 * Create a queue instance
 */
export declare function createQueue(db: any, name: string, config?: Partial<QueueConfig>): PriorityQueue;
//# sourceMappingURL=queue.d.ts.map