/**
 * Sync Manager
 *
 * Synchronizes autopilot state with the API.
 */
import { EventEmitter } from 'events';
import type { AutopilotState, TokenUsage } from '../types.js';
import type { AutopilotApiClient } from '../api/autopilot-api-client.js';
/**
 * Sync status
 */
export type SyncStatus = 'idle' | 'syncing' | 'error' | 'offline';
/**
 * Sync result
 */
export interface SyncResult {
    success: boolean;
    timestamp: Date;
    error?: string;
    latencyMs: number;
}
/**
 * Sync Manager Options
 */
export interface SyncManagerOptions {
    apiClient: AutopilotApiClient;
    syncIntervalMs?: number;
    maxRetries?: number;
    retryDelayMs?: number;
}
/**
 * Sync Manager Events
 */
export interface SyncManagerEvents {
    'sync:started': void;
    'sync:completed': {
        result: SyncResult;
    };
    'sync:failed': {
        error: string;
        retryCount: number;
    };
    'sync:offline': void;
    'sync:reconnected': void;
}
/**
 * State update for sync
 */
export interface StateUpdate {
    runId: string;
    status: string;
    completedTickets: string[];
    failedTickets: Array<{
        ticketId: string;
        error: string;
        retryCount: number;
    }>;
    currentEpic?: string;
    totalCostUsd: number;
    totalTokens: TokenUsage;
    workers: Array<{
        workerId: number;
        status: string;
        currentTicketId?: string;
        completedCount: number;
        failedCount: number;
        costUsd: number;
    }>;
    updatedAt: string;
}
/**
 * Sync Manager
 *
 * Handles periodic synchronization of autopilot state to the API.
 */
export declare class SyncManager extends EventEmitter {
    private apiClient;
    private syncIntervalMs;
    private maxRetries;
    private retryDelayMs;
    private syncTimer?;
    private status;
    private lastSync?;
    private lastSyncResult?;
    private retryCount;
    private isOffline;
    private pendingState?;
    constructor(options: SyncManagerOptions);
    /**
     * Start periodic sync
     */
    start(): void;
    /**
     * Stop periodic sync
     */
    stop(): void;
    /**
     * Queue state for sync
     */
    queueSync(state: AutopilotState): void;
    /**
     * Sync state immediately
     */
    syncState(state: AutopilotState): Promise<SyncResult>;
    /**
     * Build state update from autopilot state
     */
    private buildStateUpdate;
    /**
     * Sync ticket completion
     */
    syncTicketCompleted(ticketId: string, result: {
        success: boolean;
        output?: string;
        filesModified?: string[];
        tokensUsed?: TokenUsage;
        costUsd?: number;
        commitHash?: string;
    }): Promise<void>;
    /**
     * Sync run completion
     */
    syncRunCompleted(state: AutopilotState, summary: {
        status: string;
        completedCount: number;
        failedCount: number;
        totalCostUsd: number;
        totalTokens: TokenUsage;
        durationMs: number;
    }): Promise<void>;
    /**
     * Get sync status
     */
    getStatus(): SyncStatus;
    /**
     * Get last sync time
     */
    getLastSync(): Date | undefined;
    /**
     * Get last sync result
     */
    getLastSyncResult(): SyncResult | undefined;
    /**
     * Check if offline
     */
    isOfflineMode(): boolean;
    /**
     * Get retry count
     */
    getRetryCount(): number;
    /**
     * Force reconnect attempt
     */
    reconnect(): Promise<boolean>;
    /**
     * Get sync interval
     */
    getSyncInterval(): number;
    /**
     * Set sync interval
     */
    setSyncInterval(ms: number): void;
}
/**
 * Create a sync manager
 */
export declare function createSyncManager(options: SyncManagerOptions): SyncManager;
//# sourceMappingURL=sync-manager.d.ts.map