import { EventEmitter } from "node:events";
import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
import type { AgentEvent } from "../types.js";
import { type EventSubscription } from "./subscription-manager.js";
export interface EventWatcherConfig {
    networkId?: string;
    nodeUrl?: string;
    gasLimit?: string;
}
export interface WatchEventRequest {
    contractId: string;
    eventName: string;
    responseMethodName: string;
    responseParameterName: string;
    cronExpression?: string;
    server: Server;
}
export interface EventWatcherEvents {
    "watcher:started": [subscriptionId: string];
    "watcher:stopped": [subscriptionId: string];
    "watcher:error": [data: {
        subscriptionId: string;
        error: unknown;
    }];
    "event:detected": [
        data: {
            event: AgentEvent;
            subscription: EventSubscription;
        }
    ];
    "event:processed": [
        data: {
            requestId: string;
            response: string;
            processingTime: number;
        }
    ];
    "event:failed": [
        data: {
            requestId: string;
            error: string;
            processingTime: number;
        }
    ];
    "stats:updated": [stats: EventWatcherStats];
}
export interface EventWatcherStats {
    totalSubscriptions: number;
    activeSubscriptions: number;
    totalEventsDetected: number;
    totalEventsProcessed: number;
    totalEventsSuccessful: number;
    totalEventsFailed: number;
    successRate: number;
    averageProcessingTime: number;
    uptime: number;
}
export declare class EventWatcher extends EventEmitter<EventWatcherEvents> {
    private static instance;
    private authManager;
    private eventListener;
    private eventProcessor;
    private server;
    private isInitialized;
    private startTime;
    private stats;
    private constructor();
    static getInstance(): EventWatcher;
    /**
     * Set the MCP server instance for message creation
     */
    setServer(server: Server): void;
    /**
     * Initialize the EventWatcher - handles all authentication internally
     */
    private initialize;
    /**
     * Start watching for a specific event
     */
    watchEvent(request: WatchEventRequest): Promise<string>;
    /**
     * Stop watching a specific event
     */
    stopWatching(contractId: string, eventName: string): Promise<boolean>;
    /**
     * Stop watching all events
     */
    stopAllWatching(): Promise<void>;
    /**
     * Get current watching status
     */
    getWatchingStatus(): {
        isInitialized: boolean;
        totalSubscriptions: number;
        subscriptions: {
            id: string;
            contractId: string;
            eventName: string;
            responseMethodName: string;
            responseParameterName: string;
            cronExpression: string;
            isActive: boolean;
            createdAt: number;
            lastEventAt: number | undefined;
        }[];
        listener: {
            isInitialized: boolean;
            activeSubscriptions: number;
            authManagerStatus: {
                isInitialized: boolean;
                hasAccount: boolean;
                accountId: string | null;
                networkId: string;
            };
            processingStates: {
                subscriptionId: string;
                lastBlockHeight: number;
                isProcessing: boolean;
                processedTransactionCount: number;
            }[];
        };
        processor: import("./event-processor.js").ProcessingStats;
    };
    /**
     * Get comprehensive statistics
     */
    getStats(): EventWatcherStats;
    /**
     * Pause watching for a specific event
     */
    pauseWatching(contractId: string, eventName: string): boolean;
    /**
     * Resume watching for a specific event
     */
    resumeWatching(contractId: string, eventName: string): boolean;
    /**
     * Check if watching a specific event
     */
    isWatching(contractId: string, eventName: string): boolean;
    /**
     * Get list of all watched events
     */
    getWatchedEvents(): Array<{
        contractId: string;
        eventName: string;
        subscriptionId: string;
    }>;
    /**
     * Setup event handlers to connect EventListener and EventProcessor
     */
    private setupEventHandlers;
    /**
     * Update processing statistics
     */
    private updateProcessingStats;
    /**
     * Emit stats update event
     */
    private emitStatsUpdate;
    /**
     * Cleanup all resources
     */
    cleanup(): Promise<void>;
    on<K extends keyof EventWatcherEvents>(event: K, listener: (...args: EventWatcherEvents[K]) => void): this;
    emit<K extends keyof EventWatcherEvents>(event: K, ...args: EventWatcherEvents[K]): boolean;
    off<K extends keyof EventWatcherEvents>(event: K, listener: (...args: EventWatcherEvents[K]) => void): this;
    once<K extends keyof EventWatcherEvents>(event: K, listener: (...args: EventWatcherEvents[K]) => void): this;
}
export declare const eventWatcher: EventWatcher;