import { ChainRegistry } from '../core/registry/chain-registry.js';
import { ToolRegistry } from '../core/registry/tool-registry.js';
import { AgentCache } from '../core/cache/agent-cache.js';
import { LazyCache } from '../core/cache/lazy-cache.js';
import { IPFSService } from '../core/services/ipfs-service.js';
import type { IChainProvider } from '../core/interfaces/chain-provider.js';
import type { IEnvConfig } from '../config/env.js';
import { type NetworkMode } from '../config/defaults.js';
import type { ChainPrefix } from '../core/interfaces/agent.js';
export interface IGlobalStateConfig {
    autoSync?: boolean;
    cachePath?: string;
    networkMode?: NetworkMode;
    useLazyCache?: boolean;
    cacheTtlMs?: number;
    cacheMaxEntries?: number;
}
export interface INetworkStatus {
    mode: NetworkMode;
    deployedChains: ChainPrefix[];
    chainStatus: Record<ChainPrefix, {
        deployed: boolean;
        displayName: string;
        chainId: number | string;
        rpcUrl: string;
        hasSubgraph: boolean;
    }>;
}
export interface IGlobalStateSnapshot {
    config: IEnvConfig;
    networkMode: NetworkMode;
    chains: {
        registered: string[];
        default: string | null;
        ready: string[];
    };
    network: INetworkStatus;
    tools: {
        count: number;
    };
    cache: {
        total: number;
        byChain: Record<string, number>;
        dbSize: string;
    };
    ipfs: {
        configured: boolean;
        hasUploadBackend: boolean;
        hasPinata: boolean;
        hasIpfsNode: boolean;
        hasFilecoin: boolean;
    };
    crawlerTimeoutMs: number;
}
declare class GlobalState {
    private _config;
    private _networkMode;
    private _chainRegistry;
    private _toolRegistry;
    private _legacyCache;
    private _lazyCache;
    private _useLazyCache;
    private _crawlerTimeoutMs;
    private _ipfsService;
    private _initialized;
    private _dormantProviders;
    constructor();
    get networkMode(): NetworkMode;
    setNetworkMode(mode: NetworkMode): {
        previous: NetworkMode;
        current: NetworkMode;
        deployedChains: ChainPrefix[];
    };
    private _switchProvidersNetwork;
    private _updateSolanaProviders;
    private _reregisterEVMProviders;
    getNetworkStatus(): INetworkStatus;
    get config(): IEnvConfig;
    setConfig(updates: Partial<IEnvConfig>): void;
    resetConfig(): void;
    get crawlerTimeoutMs(): number;
    set crawlerTimeoutMs(value: number);
    get chains(): ChainRegistry;
    get tools(): ToolRegistry;
    get ipfs(): IPFSService;
    get cache(): AgentCache | LazyCache;
    get lazyCache(): LazyCache | null;
    get legacyCache(): AgentCache | null;
    get hasCache(): boolean;
    get isLazyCache(): boolean;
    initialize(config?: IGlobalStateConfig): Promise<void>;
    start(): void;
    stop(): void;
    getDefaultChain(): IChainProvider | null;
    requireDefaultChain(): IChainProvider;
    getChain(chainId?: string): IChainProvider | null;
    requireChain(chainId?: string): IChainProvider;
    getSnapshot(): IGlobalStateSnapshot;
}
export declare const globalState: GlobalState;
export { GlobalState };
export type { NetworkMode };
//# sourceMappingURL=global-state.d.ts.map