import { default as React, ReactNode } from 'react';
/**
 * Operation types that can be tracked in dry run mode
 */
export type OperationType = 'create' | 'update' | 'delete' | 'api_request' | 'state_change' | 'file_write' | 'file_delete' | 'database_write' | 'database_delete';
/**
 * Severity levels for impact analysis
 */
export type ImpactSeverity = 'low' | 'medium' | 'high' | 'critical';
/**
 * Conflict types
 */
export type ConflictType = 'resource_exists' | 'concurrent_modification' | 'dependency_missing' | 'permission_denied' | 'validation_failed';
/**
 * Change status
 */
export type ChangeStatus = 'pending' | 'approved' | 'rejected' | 'committed' | 'rolled_back' | 'failed';
/**
 * Represents a single operation change
 */
export interface OperationChange {
    id: string;
    timestamp: Date;
    type: OperationType;
    resource: string;
    action: string;
    status: ChangeStatus;
    before?: unknown;
    after?: unknown;
    metadata?: Record<string, unknown>;
    impact?: ImpactAnalysis;
    conflicts?: ConflictDetection[];
    dependencies?: string[];
    requiresApproval?: boolean;
    approvedBy?: string;
    approvedAt?: Date;
    rejectedBy?: string;
    rejectedAt?: Date;
    rejectionReason?: string;
}
/**
 * Impact analysis result
 */
export interface ImpactAnalysis {
    severity: ImpactSeverity;
    affectedResources: string[];
    estimatedDuration?: number;
    risks: string[];
    recommendations: string[];
    reversible: boolean;
}
/**
 * Conflict detection result
 */
export interface ConflictDetection {
    type: ConflictType;
    resource: string;
    message: string;
    canResolve: boolean;
    resolution?: string;
}
/**
 * Diff between before and after states
 */
export interface DiffResult {
    added: Array<{
        path: string;
        value: unknown;
    }>;
    removed: Array<{
        path: string;
        value: unknown;
    }>;
    modified: Array<{
        path: string;
        before: unknown;
        after: unknown;
    }>;
}
/**
 * Batch operation preview
 */
export interface BatchPreview {
    id: string;
    name: string;
    operations: OperationChange[];
    totalImpact: ImpactAnalysis;
    conflicts: ConflictDetection[];
    canExecute: boolean;
}
/**
 * Dry run statistics
 */
export interface DryRunStats {
    totalOperations: number;
    pendingOperations: number;
    approvedOperations: number;
    rejectedOperations: number;
    committedOperations: number;
    rolledBackOperations: number;
    failedOperations: number;
    totalConflicts: number;
    highImpactOperations: number;
}
/**
 * Dry run configuration
 */
export interface DryRunConfig {
    enabled: boolean;
    requireApproval: boolean;
    autoDetectConflicts: boolean;
    enableImpactAnalysis: boolean;
    enableDiffVisualization: boolean;
    maxPendingChanges: number;
    allowedOperations?: OperationType[];
    blockedOperations?: OperationType[];
    approvers?: string[];
    notificationUrl?: string;
}
/**
 * Manages dry run state and operations
 */
declare class DryRunStateManager {
    private enabled;
    private config;
    private changes;
    private batches;
    private listeners;
    private currentBatchId;
    constructor(config?: Partial<DryRunConfig>);
    isEnabled(): boolean;
    enable(): void;
    disable(): void;
    getConfig(): DryRunConfig;
    updateConfig(updates: Partial<DryRunConfig>): void;
    addChange(change: Omit<OperationChange, 'id' | 'timestamp' | 'status'>): string;
    getChange(id: string): OperationChange | undefined;
    getAllChanges(): OperationChange[];
    getPendingChanges(): OperationChange[];
    removeChange(id: string): boolean;
    clearChanges(): void;
    simulateState<T>(currentState: T, changes: OperationChange[]): T;
    private applyChange;
    getDiff(before: unknown, after: unknown): DiffResult;
    private compareDiff;
    detectConflicts(change: OperationChange): ConflictDetection[];
    analyzeImpact(change: OperationChange): ImpactAnalysis;
    private escalateSeverity;
    approveChange(id: string, approver: string): boolean;
    rejectChange(id: string, rejector: string, reason: string): boolean;
    startBatch(name: string): string;
    endBatch(): BatchPreview | null;
    getBatch(id: string): BatchPreview | undefined;
    getAllBatches(): BatchPreview[];
    private analyzeBatchImpact;
    private detectBatchConflicts;
    private compareSeverity;
    commitChanges(filter?: (change: OperationChange) => boolean): Promise<{
        succeeded: string[];
        failed: Array<{
            id: string;
            error: string;
        }>;
    }>;
    rollbackChange(id: string): Promise<boolean>;
    getStats(): DryRunStats;
    private generateId;
    private notifyListeners;
    subscribe(listener: (changes: OperationChange[]) => void): () => void;
}
declare const globalDryRunManager: DryRunStateManager;
interface DryRunContextValue {
    enabled: boolean;
    config: DryRunConfig;
    changes: OperationChange[];
    stats: DryRunStats;
    enableDryRun: () => void;
    disableDryRun: () => void;
    updateConfig: (config: Partial<DryRunConfig>) => void;
    addChange: (change: Omit<OperationChange, 'id' | 'timestamp' | 'status'>) => string;
    getChange: (id: string) => OperationChange | undefined;
    removeChange: (id: string) => boolean;
    clearChanges: () => void;
    getPendingChanges: () => OperationChange[];
    simulateState: <T>(currentState: T, changes?: OperationChange[]) => T;
    getDiff: (before: unknown, after: unknown) => DiffResult;
    approveChange: (id: string, approver: string) => boolean;
    rejectChange: (id: string, rejector: string, reason: string) => boolean;
    startBatch: (name: string) => string;
    endBatch: () => BatchPreview | null;
    getBatch: (id: string) => BatchPreview | undefined;
    getAllBatches: () => BatchPreview[];
    commitChanges: (filter?: (change: OperationChange) => boolean) => Promise<{
        succeeded: string[];
        failed: Array<{
            id: string;
            error: string;
        }>;
    }>;
    rollbackChange: (id: string) => Promise<boolean>;
}
export interface DryRunProviderProps {
    children: ReactNode;
    config?: Partial<DryRunConfig>;
    manager?: DryRunStateManager;
}
export declare function DryRunProvider({ children, config, manager, }: DryRunProviderProps): import("react/jsx-runtime").JSX.Element;
export declare function useDryRun(): DryRunContextValue;
export interface DryRunBannerProps {
    className?: string;
    style?: React.CSSProperties;
    showStats?: boolean;
    showActions?: boolean;
    onCommit?: () => void;
    onDiscard?: () => void;
}
export declare function DryRunBanner({ className, style, showStats, showActions, onCommit, onDiscard, }: DryRunBannerProps): import("react/jsx-runtime").JSX.Element | null;
/**
 * Enzyme Extension Definition
 * This follows the CLI extension pattern but provides state management
 * that can be used in both CLI and React contexts
 */
export declare const dryRunExtension: {
    name: string;
    version: string;
    description: string;
    client: {
        $enableDryRun(): void;
        $disableDryRun(): void;
        $isDryRunEnabled(): boolean;
        $getPendingChanges(): OperationChange[];
        $previewOperation(operation: Omit<OperationChange, "id" | "timestamp" | "status">): string;
        $simulateState<T>(currentState: T, changes?: OperationChange[]): T;
        $commitChanges(filter?: (change: OperationChange) => boolean): Promise<{
            succeeded: string[];
            failed: Array<{
                id: string;
                error: string;
            }>;
        }>;
        $discardChanges(): void;
        $getChangeDiff(before: unknown, after: unknown): DiffResult;
        $getStats(): DryRunStats;
        $updateConfig(config: Partial<DryRunConfig>): void;
        $getConfig(): DryRunConfig;
        $approveChange(id: string, approver: string): boolean;
        $rejectChange(id: string, rejector: string, reason: string): boolean;
        $startBatch(name: string): string;
        $endBatch(): BatchPreview | null;
        $getBatch(id: string): BatchPreview | undefined;
        $getAllBatches(): BatchPreview[];
        $rollbackChange(id: string): Promise<boolean>;
    };
};
export { globalDryRunManager, DryRunStateManager };