@sirmrmarty/n8n-nodes-tmux-orchestrator/dist/utils/threadSafeState.d.ts

n8n nodes for orchestrating Claude AI agents through tmux sessions

import { EventEmitter } from 'events';
export declare class ThreadSafeMap<K, V> extends EventEmitter {
    private map;
    private locks;
    private readonly lockTimeout;
    constructor(lockTimeout?: number);
    private acquireLock;
    private releaseLock;
    safeSet(key: K, value: V): Promise<void>;
    safeGet(key: K): V | undefined;
    safeDelete(key: K): Promise<boolean>;
    safeHas(key: K): boolean;
    safeKeys(): K[];
    safeValues(): V[];
    safeEntries(): [K, V][];
    safeSize(): number;
    safeClear(): Promise<void>;
    safeUpdate(key: K, updateFn: (currentValue: V | undefined) => V): Promise<V>;
    safeComputeIfAbsent(key: K, computeFn: () => Promise<V> | V): Promise<V>;
}
export declare class ThreadSafeSet<T> extends EventEmitter {
    private set;
    private locks;
    private readonly lockTimeout;
    constructor(lockTimeout?: number);
    private acquireLock;
    private releaseLock;
    safeAdd(value: T): Promise<boolean>;
    safeDelete(value: T): Promise<boolean>;
    safeHas(value: T): boolean;
    safeValues(): T[];
    safeSize(): number;
    safeClear(): Promise<void>;
}
export declare class ThreadSafeCounter extends EventEmitter {
    private value;
    private lock;
    increment(amount?: number): Promise<number>;
    decrement(amount?: number): Promise<number>;
    getValue(): number;
    setValue(newValue: number): Promise<number>;
    compareAndSwap(expected: number, newValue: number): Promise<boolean>;
}
export declare class ThreadSafeQueue<T> extends EventEmitter {
    private queue;
    private lock;
    private acquireLock;
    private releaseLock;
    enqueue(item: T): Promise<void>;
    dequeue(): Promise<T | undefined>;
    peek(): T | undefined;
    size(): number;
    isEmpty(): boolean;
    clear(): Promise<void>;
}
export declare class StateManager {
    private static instance;
    private maps;
    private sets;
    private counters;
    private queues;
    private constructor();
    static getInstance(): StateManager;
    getMap<K, V>(name: string): ThreadSafeMap<K, V>;
    getSet<T>(name: string): ThreadSafeSet<T>;
    getCounter(name: string): ThreadSafeCounter;
    getQueue<T>(name: string): ThreadSafeQueue<T>;
    removeState(name: string): boolean;
    getStats(): {
        maps: number;
        sets: number;
        counters: number;
        queues: number;
        total: number;
    };
    clearAll(): Promise<void>;
}
export declare const stateManager: StateManager;