/**
 * Relay API Client
 * TASKSET 9 Phase 9-10: API client for triggering internal events with production hardening
 *
 * Provides methods to trigger comment and version events via Relay's internal API,
 * which then broadcasts to all WebSocket subscribers via MessageRouter.
 *
 * Phase 10 Features:
 * - Exponential backoff retry logic
 * - Offline request queue with persistence
 * - Request deduplication
 * - Performance monitoring
 * - Circuit breaker pattern
 */
export interface CommentEventRequest {
    event_type: 'created' | 'updated' | 'deleted' | 'resolved' | 'reaction_added' | 'reaction_removed' | 'reply_added';
    comment_id: string;
    document_id: string;
    user_id: string;
    content?: string;
    position?: number;
    parent_id?: string;
    emoji?: string;
    timestamp: string;
}
export interface VersionEventRequest {
    event_type: 'created' | 'restored' | 'compared';
    version_id?: string;
    document_id: string;
    user_id: string;
    version_number: number;
    snapshot_size?: number;
    new_version_number?: number;
    version_from?: number;
    version_to?: number;
    timestamp: string;
}
export interface RelayClientConfig {
    baseUrl?: string;
    timeout?: number;
    retry?: RetryConfig;
    offline?: OfflineConfig;
    monitoring?: MonitoringConfig;
    circuitBreaker?: CircuitBreakerConfig;
}
/**
 * Retry configuration with exponential backoff
 */
export interface RetryConfig {
    maxRetries: number;
    baseDelay: number;
    maxDelay: number;
    retryableStatusCodes: number[];
}
/**
 * Offline queue configuration
 */
export interface OfflineConfig {
    enabled: boolean;
    maxQueueSize: number;
    persistenceKey: string;
    retryInterval: number;
}
/**
 * Performance monitoring configuration
 */
export interface MonitoringConfig {
    enabled: boolean;
    sampleRate: number;
    onMetric?: (metric: PerformanceMetric) => void;
}
/**
 * Circuit breaker configuration
 */
export interface CircuitBreakerConfig {
    enabled: boolean;
    failureThreshold: number;
    successThreshold: number;
    timeout: number;
}
/**
 * Performance metric
 */
export interface PerformanceMetric {
    operation: string;
    duration: number;
    success: boolean;
    retryCount: number;
    timestamp: number;
}
/**
 * Circuit breaker states
 */
declare enum CircuitState {
    CLOSED = "closed",
    OPEN = "open",
    HALF_OPEN = "half_open"
}
/**
 * Result type for API responses
 */
export interface ApiResult<T> {
    ok: boolean;
    data?: T;
    error?: string;
    retryCount?: number;
    fromCache?: boolean;
}
/**
 * Comment API response
 */
export interface CommentResponse {
    comment_id: string;
    document_id: string;
    user_id: string;
    content: string;
    timestamp: string;
}
/**
 * Version API response
 */
export interface VersionResponse {
    version_id: string;
    document_id: string;
    version_number: number;
    created_by: string;
    timestamp: string;
}
/**
 * Relay API Client for internal events
 *
 * This client triggers internal events that the Relay MessageRouter broadcasts
 * to WebSocket subscribers. Use this to bridge HTTP API mutations with real-time updates.
 *
 * Production Features:
 * - Automatic retry with exponential backoff
 * - Offline queue with localStorage persistence
 * - Request deduplication via request IDs
 * - Circuit breaker to prevent cascade failures
 * - Performance monitoring and metrics
 */
export declare class RelayAPIClient {
    private httpClient;
    private config;
    private circuitState;
    private failureCount;
    private successCount;
    private circuitOpenedAt;
    private offlineQueue;
    private processingQueue;
    private queueTimer;
    private pendingRequests;
    private recentRequests;
    private metrics;
    constructor(config?: RelayClientConfig);
    /**
     * Set authentication token getter
     */
    setAuthTokenGetter(getter: () => string | null): void;
    /**
     * Retry request with exponential backoff
     */
    private retryWithBackoff;
    /**
     * Check circuit breaker state
     */
    private checkCircuitBreaker;
    /**
     * Record success for circuit breaker
     */
    private recordSuccess;
    /**
     * Record failure for circuit breaker
     */
    private recordFailure;
    /**
     * Generate request ID for deduplication
     */
    private generateRequestId;
    /**
     * Check if request is duplicate
     */
    private checkDuplicate;
    /**
     * Record performance metric
     */
    private recordMetric;
    /**
     * Add request to offline queue
     */
    private addToOfflineQueue;
    /**
     * Save offline queue to localStorage
     */
    private saveOfflineQueue;
    /**
     * Load offline queue from localStorage
     */
    private loadOfflineQueue;
    /**
     * Start offline queue processor
     */
    private startQueueProcessor;
    /**
     * Process offline queue
     */
    private processOfflineQueue;
    /**
     * Get performance metrics
     */
    getMetrics(): PerformanceMetric[];
    /**
     * Get average latency
     */
    getAverageLatency(): number;
    /**
     * Get success rate
     */
    getSuccessRate(): number;
    /**
     * Get circuit breaker status
     */
    getCircuitStatus(): {
        state: CircuitState;
        failureCount: number;
        successCount: number;
    };
    /**
     * Get offline queue size
     */
    getOfflineQueueSize(): number;
    /**
     * Clear offline queue
     */
    clearOfflineQueue(): void;
    /**
     * Destroy client and cleanup
     */
    destroy(): void;
    /**
     * Execute request with all production features
     */
    private executeRequest;
    /**
     * Trigger CommentCreated event
     * Broadcasts to all document subscribers via WebSocket
     */
    triggerCommentCreated(params: {
        commentId: string;
        documentId: string;
        userId: string;
        content: string;
        position?: number;
        parentId?: string;
    }): Promise<ApiResult<void>>;
    /**
     * Trigger CommentUpdated event
     */
    triggerCommentUpdated(params: {
        commentId: string;
        documentId: string;
        userId: string;
        content: string;
    }): Promise<ApiResult<void>>;
    /**
     * Trigger CommentDeleted event
     */
    triggerCommentDeleted(params: {
        commentId: string;
        documentId: string;
        userId: string;
    }): Promise<ApiResult<void>>;
    /**
     * Trigger CommentResolved event
     */
    triggerCommentResolved(params: {
        commentId: string;
        documentId: string;
        userId: string;
    }): Promise<ApiResult<void>>;
    /**
     * Trigger CommentReactionAdded event
     */
    triggerCommentReactionAdded(params: {
        commentId: string;
        documentId: string;
        userId: string;
        emoji: string;
    }): Promise<ApiResult<void>>;
    /**
     * Trigger CommentReactionRemoved event
     */
    triggerCommentReactionRemoved(params: {
        commentId: string;
        documentId: string;
        userId: string;
        emoji: string;
    }): Promise<ApiResult<void>>;
    /**
     * Trigger CommentReplyAdded event
     */
    triggerCommentReplyAdded(params: {
        replyId: string;
        parentCommentId: string;
        documentId: string;
        userId: string;
        content: string;
    }): Promise<ApiResult<void>>;
    /**
     * Trigger VersionCreated event
     * Broadcasts to all document subscribers via WebSocket
     */
    triggerVersionCreated(params: {
        versionId: string;
        documentId: string;
        userId: string;
        versionNumber: number;
        snapshotSize: number;
    }): Promise<ApiResult<void>>;
    /**
     * Trigger VersionRestored event
     */
    triggerVersionRestored(params: {
        versionId: string;
        documentId: string;
        userId: string;
        versionNumber: number;
        newVersionNumber: number;
    }): Promise<ApiResult<void>>;
    /**
     * Trigger VersionCompared event
     */
    triggerVersionCompared(params: {
        documentId: string;
        userId: string;
        versionFrom: number;
        versionTo: number;
        diffSize: number;
    }): Promise<ApiResult<void>>;
    /**
     * Create singleton instance
     */
    private static instance;
    static getInstance(config?: RelayClientConfig): RelayAPIClient;
    /**
     * Reset singleton (useful for testing)
     */
    static resetInstance(): void;
}
/**
 * Default export for convenience
 */
export declare const relayClient: RelayAPIClient;
export {};
//# sourceMappingURL=relay.d.ts.map