interface JSONExportFormat {
  metadata?: {
    exportedAt: string;           // ISO 8601 timestamp
    totalRecords: number;         // Count of exported bookmarks
    exportOptions: ExportOptions; // Configuration used
    version: string;              // Schema version
  };
  bookmarks: BookmarkData[];      // Array of bookmark objects
}

interface CSVExportOptions extends ExportOptions {
  selectedFields: string[];         // Fields to include
  delimiter: ',' | ';' | '\t';     // Field separator
  includeHeaders: boolean;          // Column headers
  quoteStyle: 'minimal' | 'all';   // Quote handling
}

interface AdvancedExportOptions {
  // Format and structure
  format: 'json' | 'csv';
  includeMetadata: boolean;
  compressOutput?: boolean;          // GZIP compression
  filePath?: string;                 // Custom output path
  
  // Filtering and selection
  filter?: {
    tags?: string[];                 // Include only specific tags
    dateRange?: {                    // Date range filtering
      start: string;
      end: string;
    };
    mediaType?: string;              // Filter by media type
    bookmarkIds?: string[];          // Specific bookmark selection
  };
  
  // CSV-specific options
  csvOptions?: {
    selectedFields: string[];        // Column selection
    delimiter: ',' | ';' | '\t';    // Field separator
    includeHeaders: boolean;         // Header row
    quoteStyle: 'minimal' | 'all';  // Quoting strategy
    nullValue: string;               // Null representation
  };
  
  // Performance options
  batchSize?: number;                // Processing batch size
  progressCallback?: (progress: number) => void;
}

interface BatchExportResult {
  success: boolean;
  totalProcessed: number;
  batchCount: number;
  processingTimeMs: number;
  filePath?: string;
  error?: string;
}

// Large-scale export with progress tracking
const batchExport = await bookmarkManager.exportBatch({
  format: 'json',
  batchSize: 100,                    // Process 100 bookmarks per batch
  compressionLevel: 6,               // GZIP compression level
  progressCallback: (progress) => {
    console.log(`Export progress: ${progress.toFixed(1)}%`);
    updateProgressBar(progress);
  },
  errorCallback: (error, batchIndex) => {
    console.error(`Batch ${batchIndex} failed:`, error);
  }
});

interface ImportOptions {
  duplicateHandling: 'skip' | 'replace' | 'merge';
  validateData: boolean;              // Enable comprehensive validation
  preserveIds: boolean;               // Keep original IDs or regenerate
  batchSize?: number;                 // Import batch size
  progressCallback?: (progress: number) => void;
}

interface ImportResult {
  success: boolean;
  importedCount: number;              // Successfully imported bookmarks
  skippedCount: number;               // Skipped due to duplicates
  errorCount: number;                 // Failed imports
  errors?: string[];                  // Detailed error messages
  duplicates?: number;                // Detected duplicates
  processingTimeMs?: number;          // Import duration
}

interface CSVImportOptions extends ImportOptions {
  fieldMapping?: Record<string, string>;    // Map CSV columns to bookmark fields
  delimiter?: ',' | ';' | '\t';            // CSV delimiter detection/override
  hasHeaders?: boolean;                     // Header row presence
  encoding?: 'utf-8' | 'latin1' | 'ascii'; // File encoding
  skipEmptyRows?: boolean;                  // Handle empty rows
}

interface ValidationPipeline {
  // File-level validation
  validateFileFormat(content: string): ValidationResult;
  validateEncoding(content: string): ValidationResult;
  validateSize(content: string): ValidationResult;
  
  // Structure validation
  validateSchema(data: any): ValidationResult;
  validateFields(bookmarks: any[]): ValidationResult;
  validateConsistency(bookmarks: BookmarkData[]): ValidationResult;
  
  // Business logic validation
  validateDuplicates(bookmarks: BookmarkData[]): ValidationResult;
  validateReferences(bookmarks: BookmarkData[]): ValidationResult;
  validateConstraints(bookmarks: BookmarkData[]): ValidationResult;
}

interface ErrorHandling {
  // Error categories
  criticalErrors: string[];    // Stop import immediately
  recoverableErrors: string[]; // Skip item, continue import
  warnings: string[];          // Import with modifications
  
  // Recovery strategies
  autoCorrection: boolean;     // Attempt automatic fixes
  skipOnError: boolean;        // Continue despite errors
  rollbackOnFailure: boolean; // Undo partial imports
  
  // Reporting
  detailedLog: boolean;        // Full error context
  progressTracking: boolean;   // Real-time status updates
}