import { TranslationStatusManager, TranslationStatus } from './translation-status-manager';
export interface ProtectionOptions {
    respectReviewed: boolean;
    respectLocked: boolean;
    allowForceOverwrite: boolean;
    backupBeforeOverwrite: boolean;
    requireConfirmation: boolean;
    logChanges: boolean;
}
export interface ConflictResolution {
    strategy: 'keep_local' | 'keep_remote' | 'merge' | 'manual' | 'backup_and_replace';
    reason: string;
    userId?: string;
    timestamp: string;
}
export interface ProtectionResult {
    success: boolean;
    message: string;
    conflicts: Array<{
        key: string;
        language: string;
        currentStatus: TranslationStatus;
        currentText: string;
        proposedText: string;
        conflict: 'status_protected' | 'content_changed' | 'locked_entry';
        resolution?: ConflictResolution;
    }>;
    protected: Array<{
        key: string;
        language: string;
        status: TranslationStatus;
        reason: string;
    }>;
    updated: Array<{
        key: string;
        language: string;
        oldText: string;
        newText: string;
    }>;
}
export interface BackupEntry {
    key: string;
    language: string;
    originalText: string;
    translatedText: string;
    status: TranslationStatus;
    metadata: any;
    backupTimestamp: string;
    backupReason: string;
}
export declare class TranslationProtectionManager {
    private projectPath;
    private statusManager;
    private defaultOptions;
    constructor(projectPath: string, statusManager?: TranslationStatusManager);
    /**
     * Protect entries during bulk translation updates
     */
    protectDuringUpdate(updates: Array<{
        key: string;
        language: string;
        newText: string;
        source?: 'ai' | 'manual' | 'import';
    }>, options?: Partial<ProtectionOptions>): Promise<ProtectionResult>;
    /**
     * Check if an entry is protected from updates
     */
    private checkProtection;
    /**
     * Resolve conflicts interactively or programmatically
     */
    resolveConflicts(conflicts: ProtectionResult['conflicts'], strategy?: 'interactive' | ConflictResolution['strategy']): Promise<Array<{
        key: string;
        language: string;
        resolution: ConflictResolution;
        success: boolean;
        error?: string;
    }>>;
    /**
     * Prompt user for conflict resolution
     */
    private promptConflictResolution;
    /**
     * Apply conflict resolution
     */
    private applyConflictResolution;
    /**
     * Create backup of translation entry
     */
    private createBackup;
    /**
     * Log protection events
     */
    private logProtectionEvent;
    /**
     * Log conflict resolution events
     */
    private logResolutionEvent;
    /**
     * Get protection statistics
     */
    getProtectionStatistics(language?: string): Promise<{
        total: number;
        protected: {
            reviewed: number;
            locked: number;
        };
        vulnerable: number;
        recentConflicts: number;
    }>;
    /**
     * Force override protection (requires explicit confirmation)
     */
    forceOverride(key: string, language: string, newText: string, options: {
        userId: string;
        reason: string;
        createBackup: boolean;
    }): Promise<{
        success: boolean;
        message: string;
        backupCreated?: boolean;
        error?: string;
    }>;
}
/**
 * Utility function to check if incremental translation is safe
 */
export declare function checkIncrementalTranslationSafety(projectPath: string, updates: Array<{
    key: string;
    language: string;
    newText: string;
}>): Promise<{
    safe: boolean;
    conflicts: number;
    protectedEntries: number;
    recommendations: string[];
}>;
//# sourceMappingURL=translation-protection.d.ts.map