/**
 * Optimistic Redlock implementation with version-based conflict detection
 * Extends the base Redlock algorithm with optimistic concurrency control
 */
import { RedisClient } from "./types";
import { Redlock, RedlockOptions } from "./redlock";
export interface OptimisticLockOptions extends RedlockOptions {
    /**
     * Maximum number of conflict retry attempts
     */
    conflictRetryCount?: number;
    /**
     * Base delay for conflict retries (ms)
     */
    conflictRetryDelay?: number;
    /**
     * Exponential backoff factor for conflict retries
     */
    conflictBackoffFactor?: number;
}
export interface OptimisticResource {
    resource: string;
    value: string | null;
    version: number;
    ttl?: number;
}
export interface OptimisticLockResult extends OptimisticResource {
    validity: number;
    isReadOnly: boolean;
}
export declare class OptimisticLock {
    readonly redlock: OptimisticRedlock;
    readonly resource: string;
    readonly value: string | null;
    readonly version: number;
    readonly validity: number;
    readonly isReadOnly: boolean;
    private _currentVersion;
    constructor(redlock: OptimisticRedlock, result: OptimisticLockResult);
    /**
     * Get current version (may be updated after operations)
     */
    get currentVersion(): number;
    /**
     * Update value with optimistic concurrency control
     */
    update(newValue: string, ttl?: number): Promise<boolean>;
    /**
     * Delete resource with version check
     */
    delete(): Promise<boolean>;
    /**
     * Compare and swap operation
     */
    compareAndSwap(expectedValue: string, newValue: string, ttl?: number): Promise<boolean>;
    /**
     * Refresh read to get latest version
     */
    refresh(): Promise<OptimisticLock>;
}
export declare class OptimisticRedlock extends Redlock {
    protected optimisticOptions: OptimisticLockOptions;
    constructor(clients: RedisClient[], options?: Partial<OptimisticLockOptions>);
    /**
     * Perform optimistic read operation
     */
    optimisticRead(resource: string): Promise<OptimisticResource | null>;
    /**
     * Perform optimistic write with version check
     */
    optimisticWrite(resource: string, value: string, expectedVersion: number, ttl?: number): Promise<number | null>;
    /**
     * Compare and swap operation
     */
    compareAndSwap(resource: string, expectedValue: string, newValue: string, ttl?: number): Promise<number | null>;
    /**
     * Delete with version check
     */
    optimisticDelete(resource: string, expectedVersion: number): Promise<boolean>;
    /**
     * Acquire optimistic lock for reading
     */
    acquireOptimisticRead(resource: string): Promise<OptimisticLock | null>;
    /**
     * Acquire optimistic lock for writing
     */
    acquireOptimisticWrite(resource: string, ttl: number): Promise<OptimisticLock>;
    /**
     * Execute transaction with automatic conflict retry
     */
    transaction<T>(resource: string, operation: (lock: OptimisticLock) => Promise<T>, options?: {
        ttl?: number;
        maxRetries?: number;
    }): Promise<T>;
    /**
     * Rollback write operation
     */
    private rollbackWrite;
    /**
     * Execute Lua script (use client.eval directly)
     */
    private executeOptimisticScript;
    /**
     * Sleep utility (inherited from base class)
     */
    private optimisticSleep;
}
export default OptimisticRedlock;
//# sourceMappingURL=optimistic-redlock.d.ts.map