/**
 * Concurrency Control Utilities
 *
 * Provides mutex, semaphore, and atomic operation utilities
 * to prevent race conditions in PZG Pro
 */
export interface MutexLock {
    release(): void;
}
/**
 * Simple mutex implementation for async operations
 */
export declare class Mutex {
    private locked;
    private waitQueue;
    acquire(): Promise<MutexLock>;
    private createLock;
    isLocked(): boolean;
}
/**
 * Semaphore for limiting concurrent operations
 */
export declare class Semaphore {
    private permits;
    private waitQueue;
    constructor(permits: number);
    acquire(): Promise<() => void>;
    private release;
    available(): number;
}
/**
 * Read-Write lock for concurrent read access
 */
export declare class ReadWriteLock {
    private readers;
    private writers;
    private readWaitQueue;
    private writeWaitQueue;
    acquireRead(): Promise<() => void>;
    acquireWrite(): Promise<() => void>;
    private releaseRead;
    private releaseWrite;
}
/**
 * Atomic counter for safe increment/decrement operations
 */
export declare class AtomicCounter {
    private value;
    private mutex;
    increment(): Promise<number>;
    decrement(): Promise<number>;
    get(): Promise<number>;
    set(newValue: number): Promise<void>;
    compareAndSwap(expected: number, newValue: number): Promise<boolean>;
}
/**
 * Thread-safe Map implementation
 */
export declare class ConcurrentMap<K, V> {
    private map;
    private rwLock;
    get(key: K): Promise<V | undefined>;
    set(key: K, value: V): Promise<void>;
    delete(key: K): Promise<boolean>;
    has(key: K): Promise<boolean>;
    size(): Promise<number>;
    keys(): Promise<K[]>;
    values(): Promise<V[]>;
    entries(): Promise<[K, V][]>;
    clear(): Promise<void>;
    forEach(callback: (value: V, key: K) => void): Promise<void>;
    /**
     * Atomic update operation - ensures consistency
     */
    update(key: K, updater: (current: V | undefined) => V): Promise<V>;
    /**
     * Atomic upsert operation
     */
    upsert(key: K, initial: V, updater: (current: V) => V): Promise<V>;
}
/**
 * Thread-safe Array implementation
 */
export declare class ConcurrentArray<T> {
    private array;
    private mutex;
    push(...items: T[]): Promise<number>;
    pop(): Promise<T | undefined>;
    shift(): Promise<T | undefined>;
    unshift(...items: T[]): Promise<number>;
    length(): Promise<number>;
    get(index: number): Promise<T | undefined>;
    set(index: number, value: T): Promise<void>;
    slice(start?: number, end?: number): Promise<T[]>;
    filter(predicate: (value: T, index: number) => boolean): Promise<T[]>;
    forEach(callback: (value: T, index: number) => void): Promise<void>;
    clear(): Promise<void>;
    /**
     * Atomic batch operation
     */
    batch<R>(operation: (array: T[]) => R): Promise<R>;
}
/**
 * Debounce utility for preventing rapid successive calls
 */
export declare function debounce<T extends (...args: any[]) => any>(fn: T, delay: number): (...args: Parameters<T>) => Promise<ReturnType<T>>;
/**
 * Circuit breaker pattern for fault tolerance
 */
export declare class CircuitBreaker {
    private threshold;
    private timeout;
    private monitoringPeriod;
    private state;
    private failureCount;
    private nextAttempt;
    private successCount;
    constructor(threshold?: number, timeout?: number, monitoringPeriod?: number);
    execute<T>(operation: () => Promise<T>): Promise<T>;
    private onSuccess;
    private onFailure;
    getState(): string;
    reset(): void;
}
/**
 * Rate limiter for controlling request frequency
 */
export declare class RateLimiter {
    private capacity;
    private refillRate;
    private refillPeriod;
    private tokens;
    private lastRefill;
    constructor(capacity: number, refillRate: number, // tokens per second
    refillPeriod?: number);
    acquire(tokensRequested?: number): Promise<boolean>;
    private refill;
    available(): number;
}