Enforce type checking in CI (#4126)

# Description of Changes Currently, the `tsconfig.json` file enforces strict type checking, but nothing in CI checks that the code is actually correctly typed. [Vite only transpiles TypeScript code](https://vite.dev/guide/features.html#transpile-only) so doesn't ensure that the TS code we're running is correct. This PR adds running of the type checker to CI and fixes the type errors that have already crept into the codebase. Note that many of the changes I've made to 'fix the types' are just using `any` to disable the type checker because the code is under too much churn to fix anything properly at the moment. I still think enabling the type checker now is the best course of action though because otherwise we'll never be able to fix all of them, and it should at least help us not break things when adding new code. Co-authored-by: James <[email protected]>
2026-07-16 11:23:10 +02:00 · 2025-08-11 09:16:16 +01:00
parent 507ad1dc61
commit af5a9d1ae1
52 changed files with 1141 additions and 919 deletions
@@ -1,16 +1,16 @@
 /**
 * End-to-End Tests for Convert Tool
- * 
+ *
 * These tests dynamically discover available conversion endpoints and test them.
 * Tests are automatically skipped if the backend endpoint is not available.
- * 
+ *
 * Run with: npm run test:e2e or npx playwright test
 */

 import { test, expect, Page } from '@playwright/test';
-import { 
-  conversionDiscovery, 
-  type ConversionEndpoint 
+import {
+  conversionDiscovery,
+  type ConversionEndpoint
 } from '../helpers/conversionEndpointDiscovery';
 import * as path from 'path';
 import * as fs from 'fs';
@@ -25,25 +25,25 @@ const BACKEND_URL = process.env.BACKEND_URL || 'http://localhost:8080';
 */
 function resolveTestFixturePath(filename: string): string {
  const cwd = process.cwd();
-  
+
  // Try frontend/src/tests/test-fixtures/ first (from top-level)
  const topLevelPath = path.join(cwd, 'frontend', 'src', 'tests', 'test-fixtures', filename);
  if (fs.existsSync(topLevelPath)) {
    return topLevelPath;
  }
-  
+
  // Try src/tests/test-fixtures/ (from frontend directory)
  const frontendPath = path.join(cwd, 'src', 'tests', 'test-fixtures', filename);
  if (fs.existsSync(frontendPath)) {
    return frontendPath;
  }
-  
+
  // Try relative path from current test file location
  const relativePath = path.join(__dirname, '..', 'test-fixtures', filename);
  if (fs.existsSync(relativePath)) {
    return relativePath;
  }
-  
+
  // Fallback to the original path format (should work from top-level)
  return path.join('.', 'frontend', 'src', 'tests', 'test-fixtures', filename);
 }
@@ -98,7 +98,7 @@ const getTestFileForFormat = (format: string): string => {
    'xml': TEST_FILES.xml,
    'csv': TEST_FILES.csv
  };
-  
+
  return formatMap[format] || TEST_FILES.pdf; // Fallback to PDF
 };

@@ -123,7 +123,7 @@ const getExpectedExtension = (toFormat: string): string => {
    'webp': '.webp',
    'pdfa': '.pdf'
  };
-  
+
  return extensionMap[toFormat] || '.pdf';
 };

@@ -133,17 +133,17 @@ const getExpectedExtension = (toFormat: string): string => {
 async function uploadFileViaModal(page: Page, filePath: string) {
  // Click the Files button in the QuickAccessBar to open the modal
  await page.click('[data-testid="files-button"]');
-  
+
  // Wait for the modal to open
-  await page.waitForSelector('.mantine-Modal-overlay', { state: 'visible' }, { timeout: 5000 });
+  await page.waitForSelector('.mantine-Modal-overlay', { state: 'visible', timeout: 5000 });
  //await page.waitForSelector('[data-testid="file-upload-modal"]', { timeout: 5000 });
-  
+
  // Upload the file through the modal's file input
  await page.setInputFiles('input[type="file"]', filePath);
-  
+
  // Wait for the file to be processed and the modal to close
  await page.waitForSelector('[data-testid="file-upload-modal"]', { state: 'hidden' });
-  
+
  // Wait for the file thumbnail to appear in the main interface
  await page.waitForSelector('[data-testid="file-thumbnail"]', { timeout: 10000 });
 }
@@ -153,33 +153,33 @@ async function uploadFileViaModal(page: Page, filePath: string) {
 */
 async function testConversion(page: Page, conversion: ConversionEndpoint) {
  const expectedExtension = getExpectedExtension(conversion.toFormat);
-  
+
  console.log(`Testing ${conversion.endpoint}: ${conversion.fromFormat} → ${conversion.toFormat}`);
-  
+
  // File should already be uploaded, click the Convert tool button
  await page.click('[data-testid="tool-convert"]');
-  
+
  // Wait for the FileEditor to load in convert mode with file thumbnails
  await page.waitForSelector('[data-testid="file-thumbnail"]', { timeout: 5000 });
-  
+
  // Click the file thumbnail checkbox to select it in the FileEditor
  await page.click('[data-testid="file-thumbnail-checkbox"]');
-  
+
  // Wait for the conversion settings to appear after file selection
  await page.waitForSelector('[data-testid="convert-from-dropdown"]', { timeout: 5000 });
-  
+
  // Select FROM format
  await page.click('[data-testid="convert-from-dropdown"]');
  const fromFormatOption = page.locator(`[data-testid="format-option-${conversion.fromFormat}"]`);
  await fromFormatOption.scrollIntoViewIfNeeded();
  await fromFormatOption.click();
-  
+
  // Select TO format
  await page.click('[data-testid="convert-to-dropdown"]');
  const toFormatOption = page.locator(`[data-testid="format-option-${conversion.toFormat}"]`);
  await toFormatOption.scrollIntoViewIfNeeded();
  await toFormatOption.click();
-  
+
  // Handle format-specific options
  if (conversion.toFormat === 'image' || ['png', 'jpg', 'jpeg', 'gif', 'bmp', 'tiff', 'webp'].includes(conversion.toFormat)) {
    // Set image conversion options if they appear
@@ -188,17 +188,17 @@ async function testConversion(page: Page, conversion: ConversionEndpoint) {
      // Click the color type dropdown and select "Color"
      await page.click('[data-testid="color-type-select"]');
      await page.getByRole('option', { name: 'Color' }).click();
-      
+
      // Set DPI value
      await page.fill('[data-testid="dpi-input"]', '150');
-      
+
      // Click the output type dropdown and select "Multiple"
      await page.click('[data-testid="output-type-select"]');
-      
+
      await page.getByRole('option', { name: 'single' }).click();
    }
  }
-  
+
  if (conversion.fromFormat === 'image' && conversion.toFormat === 'pdf') {
    // Set PDF creation options if they appear
    const pdfOptionsVisible = await page.locator('[data-testid="pdf-options-section"]').isVisible().catch(() => false);
@@ -208,7 +208,7 @@ async function testConversion(page: Page, conversion: ConversionEndpoint) {
      await page.locator('[data-value="color"]').click();
    }
  }
-  
+
  if (conversion.fromFormat === 'pdf' && conversion.toFormat === 'csv') {
    // Set CSV extraction options if they appear
    const csvOptionsVisible = await page.locator('[data-testid="csv-options-section"]').isVisible().catch(() => false);
@@ -217,32 +217,32 @@ async function testConversion(page: Page, conversion: ConversionEndpoint) {
      await page.fill('[data-testid="page-numbers-input"]', '1-2');
    }
  }
-  
+
  // Start conversion
  await page.click('[data-testid="convert-button"]');
-  
+
  // Wait for conversion to complete (with generous timeout)
  await page.waitForSelector('[data-testid="download-button"]', { timeout: 60000 });
-  
+
  // Verify download is available
  const downloadButton = page.locator('[data-testid="download-button"]');
  await expect(downloadButton).toBeVisible();
-  
+
  // Start download and verify file
  const downloadPromise = page.waitForEvent('download');
  await downloadButton.click();
  const download = await downloadPromise;
-  
+
  // Verify file extension
  expect(download.suggestedFilename()).toMatch(new RegExp(`\\${expectedExtension}$`));
-  
+
  // Save and verify file is not empty
  const path = await download.path();
  if (path) {
    const fs = require('fs');
    const stats = fs.statSync(path);
    expect(stats.size).toBeGreaterThan(0);
-    
+
    // Format-specific validations
    if (conversion.toFormat === 'pdf' || conversion.toFormat === 'pdfa') {
      // Verify PDF header
@@ -250,13 +250,13 @@ async function testConversion(page: Page, conversion: ConversionEndpoint) {
      const header = buffer.toString('utf8', 0, 4);
      expect(header).toBe('%PDF');
    }
-    
+
    if (conversion.toFormat === 'txt') {
      // Verify text content exists
      const content = fs.readFileSync(path, 'utf8');
      expect(content.length).toBeGreaterThan(0);
    }
-    
+
    if (conversion.toFormat === 'csv') {
      // Verify CSV content contains separators
      const content = fs.readFileSync(path, 'utf8');
@@ -282,18 +282,18 @@ let unavailableConversions: ConversionEndpoint[] = [];
 })();

 test.describe('Convert Tool E2E Tests', () => {
-  
+
  test.beforeAll(async () => {
    // Re-discover to ensure fresh data at test time
    console.log('Re-discovering available conversion endpoints...');
    availableConversions = await conversionDiscovery.getAvailableConversions();
    unavailableConversions = await conversionDiscovery.getUnavailableConversions();
-    
+
    console.log(`Found ${availableConversions.length} available conversions:`);
    availableConversions.forEach(conv => {
      console.log(`  ✓ ${conv.endpoint}: ${conv.fromFormat} → ${conv.toFormat}`);
    });
-    
+
    if (unavailableConversions.length > 0) {
      console.log(`Found ${unavailableConversions.length} unavailable conversions:`);
      unavailableConversions.forEach(conv => {
@@ -301,136 +301,190 @@ test.describe('Convert Tool E2E Tests', () => {
      });
    }
  });
-  
+
  test.beforeEach(async ({ page }) => {
-    // Navigate to the homepage 
+    // Navigate to the homepage
    await page.goto(`${BASE_URL}`);
-    
+
    // Wait for the page to load
    await page.waitForLoadState('networkidle');
-    
+
    // Wait for the QuickAccessBar to appear
    await page.waitForSelector('[data-testid="files-button"]', { timeout: 10000 });
  });

  test.describe('Dynamic Conversion Tests', () => {
-    
+
    // Generate a test for each potentially available conversion
    // We'll discover all possible conversions and then skip unavailable ones at runtime
    test('PDF to PNG conversion', async ({ page }) => {
-      const conversion = { endpoint: '/api/v1/convert/pdf/img', fromFormat: 'pdf', toFormat: 'png' };
+      const conversion: ConversionEndpoint = {
+        endpoint: '/api/v1/convert/pdf/img',
+        fromFormat: 'pdf',
+        toFormat: 'png',
+        description: '',
+        apiPath: ''
+      };
      const isAvailable = availableConversions.some(c => c.apiPath === conversion.endpoint);
      test.skip(!isAvailable, `Endpoint ${conversion.endpoint} is not available`);
-      
+
      const testFile = getTestFileForFormat(conversion.fromFormat);
      await uploadFileViaModal(page, testFile);
-      
+
      await testConversion(page, conversion);
    });

    test('PDF to DOCX conversion', async ({ page }) => {
-      const conversion = { endpoint: '/api/v1/convert/pdf/word', fromFormat: 'pdf', toFormat: 'docx' };
+      const conversion: ConversionEndpoint = {
+        endpoint: '/api/v1/convert/pdf/word',
+        fromFormat: 'pdf',
+        toFormat: 'docx',
+        description: '',
+        apiPath: ''
+      };
      const isAvailable = availableConversions.some(c => c.apiPath === conversion.endpoint);
      test.skip(!isAvailable, `Endpoint ${conversion.endpoint} is not available`);
-      
+
      const testFile = getTestFileForFormat(conversion.fromFormat);
      await uploadFileViaModal(page, testFile);
-      
+
      await testConversion(page, conversion);
    });

    test('DOCX to PDF conversion', async ({ page }) => {
-      const conversion = { endpoint: '/api/v1/convert/file/pdf', fromFormat: 'docx', toFormat: 'pdf' };
+      const conversion: ConversionEndpoint = {
+          endpoint: '/api/v1/convert/file/pdf',
+          fromFormat: 'docx',
+          toFormat: 'pdf',
+          description: '',
+          apiPath: ''
+      };
      const isAvailable = availableConversions.some(c => c.apiPath === conversion.endpoint);
      test.skip(!isAvailable, `Endpoint ${conversion.endpoint} is not available`);
-      
+
      const testFile = getTestFileForFormat(conversion.fromFormat);
      await uploadFileViaModal(page, testFile);
-      
+
      await testConversion(page, conversion);
    });

    test('Image to PDF conversion', async ({ page }) => {
-      const conversion = { endpoint: '/api/v1/convert/img/pdf', fromFormat: 'png', toFormat: 'pdf' };
+      const conversion: ConversionEndpoint = {
+        endpoint: '/api/v1/convert/img/pdf',
+        fromFormat: 'png',
+        toFormat: 'pdf',
+        description: '',
+        apiPath: ''
+      };
      const isAvailable = availableConversions.some(c => c.apiPath === conversion.endpoint);
      test.skip(!isAvailable, `Endpoint ${conversion.endpoint} is not available`);
-      
+
      const testFile = getTestFileForFormat(conversion.fromFormat);
      await uploadFileViaModal(page, testFile);
-      
+
      await testConversion(page, conversion);
    });

    test('PDF to TXT conversion', async ({ page }) => {
-      const conversion = { endpoint: '/api/v1/convert/pdf/text', fromFormat: 'pdf', toFormat: 'txt' };
+      const conversion: ConversionEndpoint = {
+        endpoint: '/api/v1/convert/pdf/text',
+        fromFormat: 'pdf',
+        toFormat: 'txt',
+        description: '',
+        apiPath: ''
+      };
      const isAvailable = availableConversions.some(c => c.apiPath === conversion.endpoint);
      test.skip(!isAvailable, `Endpoint ${conversion.endpoint} is not available`);
-      
+
      const testFile = getTestFileForFormat(conversion.fromFormat);
      await uploadFileViaModal(page, testFile);
-      
+
      await testConversion(page, conversion);
    });

    test('PDF to HTML conversion', async ({ page }) => {
-      const conversion = { endpoint: '/api/v1/convert/pdf/html', fromFormat: 'pdf', toFormat: 'html' };
+      const conversion: ConversionEndpoint = {
+        endpoint: '/api/v1/convert/pdf/html',
+        fromFormat: 'pdf',
+        toFormat: 'html',
+        description: '',
+        apiPath: ''
+      };
      const isAvailable = availableConversions.some(c => c.apiPath === conversion.endpoint);
      test.skip(!isAvailable, `Endpoint ${conversion.endpoint} is not available`);
-      
+
      const testFile = getTestFileForFormat(conversion.fromFormat);
      await uploadFileViaModal(page, testFile);
-      
+
      await testConversion(page, conversion);
    });

    test('PDF to XML conversion', async ({ page }) => {
-      const conversion = { endpoint: '/api/v1/convert/pdf/xml', fromFormat: 'pdf', toFormat: 'xml' };
+      const conversion: ConversionEndpoint = {
+        endpoint: '/api/v1/convert/pdf/xml',
+        fromFormat: 'pdf',
+        toFormat: 'xml',
+        description: '',
+        apiPath: ''
+      };
      const isAvailable = availableConversions.some(c => c.apiPath === conversion.endpoint);
      test.skip(!isAvailable, `Endpoint ${conversion.endpoint} is not available`);
-      
+
      const testFile = getTestFileForFormat(conversion.fromFormat);
      await uploadFileViaModal(page, testFile);
-      
+
      await testConversion(page, conversion);
    });

    test('PDF to CSV conversion', async ({ page }) => {
-      const conversion = { endpoint: '/api/v1/convert/pdf/csv', fromFormat: 'pdf', toFormat: 'csv' };
+      const conversion: ConversionEndpoint = {
+        endpoint: '/api/v1/convert/pdf/csv',
+        fromFormat: 'pdf',
+        toFormat: 'csv',
+        description: '',
+        apiPath: ''
+      };
      const isAvailable = availableConversions.some(c => c.apiPath === conversion.endpoint);
      test.skip(!isAvailable, `Endpoint ${conversion.endpoint} is not available`);
-      
+
      const testFile = getTestFileForFormat(conversion.fromFormat);
      await uploadFileViaModal(page, testFile);
-      
+
      await testConversion(page, conversion);
    });

    test('PDF to PDFA conversion', async ({ page }) => {
-      const conversion = { endpoint: '/api/v1/convert/pdf/pdfa', fromFormat: 'pdf', toFormat: 'pdfa' };
+      const conversion: ConversionEndpoint = {
+          endpoint: '/api/v1/convert/pdf/pdfa',
+          fromFormat: 'pdf',
+          toFormat: 'pdfa',
+          description: '',
+          apiPath: ''
+      };
      const isAvailable = availableConversions.some(c => c.apiPath === conversion.endpoint);
      test.skip(!isAvailable, `Endpoint ${conversion.endpoint} is not available`);
-      
+
      const testFile = getTestFileForFormat(conversion.fromFormat);
      await uploadFileViaModal(page, testFile);
-      
+
      await testConversion(page, conversion);
    });
  });

  test.describe('Static Tests', () => {
-    
+
    // Test that disabled conversions don't appear in dropdowns when they shouldn't
    test('should not show conversion button when no valid conversions available', async ({ page }) => {
      // This test ensures the convert button is disabled when no valid conversion is possible
      await uploadFileViaModal(page, TEST_FILES.pdf);
-      
+
      // Click the Convert tool button
      await page.click('[data-testid="tool-convert"]');
-      
+
      // Wait for convert mode and select file
      await page.waitForSelector('[data-testid="file-thumbnail"]', { timeout: 5000 });
      await page.click('[data-testid="file-thumbnail-checkbox"]');
-      
+
      // Don't select any formats - convert button should not exist
      const convertButton = page.locator('[data-testid="convert-button"]');
      await expect(convertButton).toHaveCount(0);
@@ -1,6 +1,6 @@
 /**
 * Integration tests for Convert Tool - Tests actual conversion functionality
- * 
+ *
 * These tests verify the integration between frontend components and backend:
 * 1. useConvertOperation hook makes correct API calls
 * 2. File upload/download flow functions properly
@@ -10,7 +10,7 @@
 */

 import React from 'react';
-import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, test, expect, vi, beforeEach, afterEach, Mock } from 'vitest';
 import { renderHook, act, waitFor } from '@testing-library/react';
 import { useConvertOperation } from '../../hooks/tools/convert/useConvertOperation';
 import { ConvertParameters } from '../../hooks/tools/convert/useConvertParameters';
@@ -28,8 +28,8 @@ vi.mock('../../services/fileStorage', () => ({
  fileStorage: {
    init: vi.fn().mockResolvedValue(undefined),
    storeFile: vi.fn().mockImplementation((file, thumbnail) => {
-      return Promise.resolve({ 
-        id: `mock-id-${file.name}`, 
+      return Promise.resolve({
+        id: `mock-id-${file.name}`,
        name: file.name,
        size: file.size,
        type: file.type,
@@ -70,7 +70,7 @@ const TestWrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => (
 );

 describe('Convert Tool Integration Tests', () => {
-  
+
  beforeEach(() => {
    vi.clearAllMocks();
    // Setup default axios mock
@@ -82,10 +82,10 @@ describe('Convert Tool Integration Tests', () => {
  });

  describe('useConvertOperation Integration', () => {
-    
+
    test('should make correct API call for PDF to PNG conversion', async () => {
      const mockBlob = new Blob(['fake-image-data'], { type: 'image/png' });
-      mockedAxios.post.mockResolvedValueOnce({
+      (mockedAxios.post as Mock).mockResolvedValueOnce({
        data: mockBlob,
        status: 200,
        statusText: 'OK'
@@ -108,7 +108,19 @@ describe('Convert Tool Integration Tests', () => {
          combineImages: true
        },
        isSmartDetection: false,
-        smartDetectionType: 'none'
+        smartDetectionType: 'none',
+        htmlOptions: {
+          zoomLevel: 0
+        },
+        emailOptions: {
+          includeAttachments: false,
+          maxAttachmentSizeMB: 0,
+          downloadHtml: false,
+          includeAllRecipients: false
+        },
+        pdfaOptions: {
+          outputFormat: ''
+        }
      };

      await act(async () => {
@@ -123,7 +135,7 @@ describe('Convert Tool Integration Tests', () => {
      );

      // Verify FormData contains correct parameters
-      const formDataCall = mockedAxios.post.mock.calls[0][1] as FormData;
+      const formDataCall = (mockedAxios.post as Mock).mock.calls[0][1] as FormData;
      expect(formDataCall.get('imageFormat')).toBe('png');
      expect(formDataCall.get('colorType')).toBe('color');
      expect(formDataCall.get('dpi')).toBe('300');
@@ -138,7 +150,7 @@ describe('Convert Tool Integration Tests', () => {

    test('should handle API error responses correctly', async () => {
      const errorMessage = 'Invalid file format';
-      mockedAxios.post.mockRejectedValueOnce({
+      (mockedAxios.post as Mock).mockRejectedValueOnce({
        response: {
          status: 400,
          data: errorMessage
@@ -163,7 +175,19 @@ describe('Convert Tool Integration Tests', () => {
          combineImages: true
        },
        isSmartDetection: false,
-        smartDetectionType: 'none'
+        smartDetectionType: 'none',
+        htmlOptions: {
+          zoomLevel: 0
+        },
+        emailOptions: {
+          includeAttachments: false,
+          maxAttachmentSizeMB: 0,
+          downloadHtml: false,
+          includeAllRecipients: false
+        },
+        pdfaOptions: {
+          outputFormat: ''
+        }
      };

      await act(async () => {
@@ -177,7 +201,7 @@ describe('Convert Tool Integration Tests', () => {
    });

    test('should handle network errors gracefully', async () => {
-      mockedAxios.post.mockRejectedValueOnce(new Error('Network error'));
+      (mockedAxios.post as Mock).mockRejectedValueOnce(new Error('Network error'));

      const { result } = renderHook(() => useConvertOperation(), {
        wrapper: TestWrapper
@@ -196,7 +220,19 @@ describe('Convert Tool Integration Tests', () => {
          combineImages: true
        },
        isSmartDetection: false,
-        smartDetectionType: 'none'
+        smartDetectionType: 'none',
+        htmlOptions: {
+          zoomLevel: 0
+        },
+        emailOptions: {
+          includeAttachments: false,
+          maxAttachmentSizeMB: 0,
+          downloadHtml: false,
+          includeAllRecipients: false
+        },
+        pdfaOptions: {
+          outputFormat: ''
+        }
      };

      await act(async () => {
@@ -209,10 +245,10 @@ describe('Convert Tool Integration Tests', () => {
  });

  describe('API and Hook Integration', () => {
-    
+
    test('should correctly map image conversion parameters to API call', async () => {
      const mockBlob = new Blob(['fake-data'], { type: 'image/jpeg' });
-      mockedAxios.post.mockResolvedValueOnce({ 
+      (mockedAxios.post as Mock).mockResolvedValueOnce({
        data: mockBlob,
        status: 200,
        headers: {
@@ -229,7 +265,6 @@ describe('Convert Tool Integration Tests', () => {
      const parameters: ConvertParameters = {
        fromExtension: 'pdf',
        toExtension: 'jpg',
-        pageNumbers: 'all',
        imageOptions: {
          colorType: 'grayscale',
          dpi: 150,
@@ -239,7 +274,19 @@ describe('Convert Tool Integration Tests', () => {
          combineImages: true
        },
        isSmartDetection: false,
-        smartDetectionType: 'none'
+        smartDetectionType: 'none',
+        htmlOptions: {
+          zoomLevel: 0
+        },
+        emailOptions: {
+          includeAttachments: false,
+          maxAttachmentSizeMB: 0,
+          downloadHtml: false,
+          includeAllRecipients: false
+        },
+        pdfaOptions: {
+          outputFormat: ''
+        }
      };

      await act(async () => {
@@ -247,12 +294,12 @@ describe('Convert Tool Integration Tests', () => {
      });

      // Verify integration: hook parameters → FormData → axios call → hook state
-      const formDataCall = mockedAxios.post.mock.calls[0][1] as FormData;
+      const formDataCall = (mockedAxios.post as Mock).mock.calls[0][1] as FormData;
      expect(formDataCall.get('imageFormat')).toBe('jpg');
      expect(formDataCall.get('colorType')).toBe('grayscale');
      expect(formDataCall.get('dpi')).toBe('150');
      expect(formDataCall.get('singleOrMultiple')).toBe('single');
-      
+
      // Verify complete workflow: API response → hook state → FileContext integration
      expect(result.current.downloadUrl).toBeTruthy();
      expect(result.current.files).toHaveLength(1);
@@ -262,7 +309,7 @@ describe('Convert Tool Integration Tests', () => {

    test('should make correct API call for PDF to CSV conversion with simplified workflow', async () => {
      const mockBlob = new Blob(['fake-csv-data'], { type: 'text/csv' });
-      mockedAxios.post.mockResolvedValueOnce({
+      (mockedAxios.post as Mock).mockResolvedValueOnce({
        data: mockBlob,
        status: 200,
        statusText: 'OK'
@@ -285,7 +332,19 @@ describe('Convert Tool Integration Tests', () => {
          combineImages: true
        },
        isSmartDetection: false,
-        smartDetectionType: 'none'
+        smartDetectionType: 'none',
+        htmlOptions: {
+          zoomLevel: 0
+        },
+        emailOptions: {
+          includeAttachments: false,
+          maxAttachmentSizeMB: 0,
+          downloadHtml: false,
+          includeAllRecipients: false
+        },
+        pdfaOptions: {
+          outputFormat: ''
+        }
      };

      await act(async () => {
@@ -300,7 +359,7 @@ describe('Convert Tool Integration Tests', () => {
      );

      // Verify FormData contains correct parameters for simplified CSV conversion
-      const formDataCall = mockedAxios.post.mock.calls[0][1] as FormData;
+      const formDataCall = (mockedAxios.post as Mock).mock.calls[0][1] as FormData;
      expect(formDataCall.get('pageNumbers')).toBe('all'); // Always "all" for simplified workflow
      expect(formDataCall.get('fileInput')).toBe(testFile);

@@ -329,7 +388,19 @@ describe('Convert Tool Integration Tests', () => {
          combineImages: true
        },
        isSmartDetection: false,
-        smartDetectionType: 'none'
+        smartDetectionType: 'none',
+        htmlOptions: {
+          zoomLevel: 0
+        },
+        emailOptions: {
+          includeAttachments: false,
+          maxAttachmentSizeMB: 0,
+          downloadHtml: false,
+          includeAllRecipients: false
+        },
+        pdfaOptions: {
+          outputFormat: ''
+        }
      };

      await act(async () => {
@@ -345,10 +416,10 @@ describe('Convert Tool Integration Tests', () => {
  });

  describe('File Upload Integration', () => {
-    
+
    test('should handle multiple file uploads correctly', async () => {
      const mockBlob = new Blob(['zip-content'], { type: 'application/zip' });
-      mockedAxios.post.mockResolvedValueOnce({ data: mockBlob });
+      (mockedAxios.post as Mock).mockResolvedValueOnce({ data: mockBlob });

      const { result } = renderHook(() => useConvertOperation(), {
        wrapper: TestWrapper
@@ -369,7 +440,19 @@ describe('Convert Tool Integration Tests', () => {
          combineImages: true
        },
        isSmartDetection: false,
-        smartDetectionType: 'none'
+        smartDetectionType: 'none',
+        htmlOptions: {
+          zoomLevel: 0
+        },
+        emailOptions: {
+          includeAttachments: false,
+          maxAttachmentSizeMB: 0,
+          downloadHtml: false,
+          includeAllRecipients: false
+        },
+        pdfaOptions: {
+          outputFormat: ''
+        }
      };

      await act(async () => {
@@ -377,14 +460,14 @@ describe('Convert Tool Integration Tests', () => {
      });

      // Verify both files were uploaded
-      const calls = mockedAxios.post.mock.calls;
+      const calls = (mockedAxios.post as Mock).mock.calls;

      for (let i = 0; i < calls.length; i++) {
        const formData = calls[i][1] as FormData;
        const fileInputs = formData.getAll('fileInput');
        expect(fileInputs).toHaveLength(1);
        expect(fileInputs[0]).toBeInstanceOf(File);
-        expect(fileInputs[0].name).toBe(files[i].name);
+        expect((fileInputs[0] as File).name).toBe(files[i].name);
      }

    });
@@ -406,7 +489,19 @@ describe('Convert Tool Integration Tests', () => {
          combineImages: true
        },
        isSmartDetection: false,
-        smartDetectionType: 'none'
+        smartDetectionType: 'none',
+        htmlOptions: {
+          zoomLevel: 0
+        },
+        emailOptions: {
+          includeAttachments: false,
+          maxAttachmentSizeMB: 0,
+          downloadHtml: false,
+          includeAllRecipients: false
+        },
+        pdfaOptions: {
+          outputFormat: ''
+        }
      };

      await act(async () => {
@@ -419,9 +514,9 @@ describe('Convert Tool Integration Tests', () => {
  });

  describe('Error Boundary Integration', () => {
-    
+
    test('should handle corrupted file gracefully', async () => {
-      mockedAxios.post.mockRejectedValueOnce({
+      (mockedAxios.post as Mock).mockRejectedValueOnce({
        response: {
          status: 422,
          data: 'Processing failed'
@@ -445,7 +540,19 @@ describe('Convert Tool Integration Tests', () => {
          combineImages: true
        },
        isSmartDetection: false,
-        smartDetectionType: 'none'
+        smartDetectionType: 'none',
+        htmlOptions: {
+          zoomLevel: 0
+        },
+        emailOptions: {
+          includeAttachments: false,
+          maxAttachmentSizeMB: 0,
+          downloadHtml: false,
+          includeAllRecipients: false
+        },
+        pdfaOptions: {
+          outputFormat: ''
+        }
      };

      await act(async () => {
@@ -457,7 +564,7 @@ describe('Convert Tool Integration Tests', () => {
    });

    test('should handle backend service unavailable', async () => {
-      mockedAxios.post.mockRejectedValueOnce({
+      (mockedAxios.post as Mock).mockRejectedValueOnce({
        response: {
          status: 503,
          data: 'Service unavailable'
@@ -481,7 +588,19 @@ describe('Convert Tool Integration Tests', () => {
          combineImages: true
        },
        isSmartDetection: false,
-        smartDetectionType: 'none'
+        smartDetectionType: 'none',
+        htmlOptions: {
+          zoomLevel: 0
+        },
+        emailOptions: {
+          includeAttachments: false,
+          maxAttachmentSizeMB: 0,
+          downloadHtml: false,
+          includeAllRecipients: false
+        },
+        pdfaOptions: {
+          outputFormat: ''
+        }
      };

      await act(async () => {
@@ -494,10 +613,10 @@ describe('Convert Tool Integration Tests', () => {
  });

  describe('FileContext Integration', () => {
-    
+
    test('should record operation in FileContext', async () => {
      const mockBlob = new Blob(['fake-data'], { type: 'image/png' });
-      mockedAxios.post.mockResolvedValueOnce({ 
+      (mockedAxios.post as Mock).mockResolvedValueOnce({
        data: mockBlob,
        status: 200,
        headers: {
@@ -523,7 +642,19 @@ describe('Convert Tool Integration Tests', () => {
          combineImages: true
        },
        isSmartDetection: false,
-        smartDetectionType: 'none'
+        smartDetectionType: 'none',
+        htmlOptions: {
+          zoomLevel: 0
+        },
+        emailOptions: {
+          includeAttachments: false,
+          maxAttachmentSizeMB: 0,
+          downloadHtml: false,
+          includeAllRecipients: false
+        },
+        pdfaOptions: {
+          outputFormat: ''
+        }
      };

      await act(async () => {
@@ -538,7 +669,7 @@ describe('Convert Tool Integration Tests', () => {

    test('should clean up blob URLs on reset', async () => {
      const mockBlob = new Blob(['fake-data'], { type: 'image/png' });
-      mockedAxios.post.mockResolvedValueOnce({ 
+      (mockedAxios.post as Mock).mockResolvedValueOnce({
        data: mockBlob,
        status: 200,
        headers: {
@@ -564,7 +695,19 @@ describe('Convert Tool Integration Tests', () => {
          combineImages: true
        },
        isSmartDetection: false,
-        smartDetectionType: 'none'
+        smartDetectionType: 'none',
+        htmlOptions: {
+          zoomLevel: 0
+        },
+        emailOptions: {
+          includeAttachments: false,
+          maxAttachmentSizeMB: 0,
+          downloadHtml: false,
+          includeAllRecipients: false
+        },
+        pdfaOptions: {
+          outputFormat: ''
+        }
      };

      await act(async () => {
@@ -586,35 +729,35 @@ describe('Convert Tool Integration Tests', () => {

 /**
 * Additional Integration Tests That Require Real Backend
- * 
+ *
 * These tests would require a running backend server and are better suited
 * for E2E testing with tools like Playwright or Cypress:
- * 
+ *
 * 1. **Real File Conversion Tests**
 *    - Upload actual PDF files and verify conversion quality
 *    - Test image format outputs are valid and viewable
 *    - Test CSV/TXT outputs contain expected content
 *    - Test file size limits and memory constraints
- * 
+ *
 * 2. **Performance Integration Tests**
 *    - Test conversion time for various file sizes
 *    - Test memory usage during large file conversions
 *    - Test concurrent conversion requests
 *    - Test timeout handling for long-running conversions
- * 
+ *
 * 3. **Authentication Integration**
 *    - Test conversions with and without authentication
 *    - Test rate limiting and user quotas
 *    - Test permission-based endpoint access
- * 
+ *
 * 4. **File Preview Integration**
 *    - Test that converted files integrate correctly with viewer
 *    - Test thumbnail generation for converted files
 *    - Test file download functionality
 *    - Test FileContext persistence across tool switches
- * 
+ *
 * 5. **Endpoint Availability Tests**
 *    - Test real endpoint availability checking
 *    - Test graceful degradation when endpoints are disabled
 *    - Test dynamic endpoint configuration updates
- */
+ */
@@ -4,7 +4,7 @@
 */

 import React from 'react';
-import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, test, expect, vi, beforeEach, afterEach, Mock } from 'vitest';
 import { renderHook, act, waitFor } from '@testing-library/react';
 import { useConvertOperation } from '../../hooks/tools/convert/useConvertOperation';
 import { useConvertParameters } from '../../hooks/tools/convert/useConvertParameters';
@@ -54,12 +54,12 @@ const TestWrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => (
 );

 describe('Convert Tool - Smart Detection Integration Tests', () => {
-  
+
  beforeEach(() => {
    vi.clearAllMocks();
-    
+
    // Mock successful API response
-    mockedAxios.post.mockResolvedValue({
+    (mockedAxios.post as Mock).mockResolvedValue({
      data: new Blob(['fake converted content'], { type: 'application/pdf' })
    });
  });
@@ -74,25 +74,25 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
      const { result: paramsResult } = renderHook(() => useConvertParameters(), {
        wrapper: TestWrapper
      });
-      
+
      const { result: operationResult } = renderHook(() => useConvertOperation(), {
        wrapper: TestWrapper
      });
-      
+
      // Create mock DOCX file
      const docxFile = new File(['docx content'], 'document.docx', { type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' });
-      
+
      // Test auto-detection
      act(() => {
        paramsResult.current.analyzeFileTypes([docxFile]);
      });
-      
+
      await waitFor(() => {
        expect(paramsResult.current.parameters.fromExtension).toBe('docx');
        expect(paramsResult.current.parameters.toExtension).toBe('pdf');
        expect(paramsResult.current.parameters.isSmartDetection).toBe(false);
      });
-      
+
      // Test conversion operation
      await act(async () => {
        await operationResult.current.executeOperation(
@@ -100,7 +100,7 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
          [docxFile]
        );
      });
-      
+
      expect(mockedAxios.post).toHaveBeenCalledWith('/api/v1/convert/file/pdf', expect.any(FormData), {
        responseType: 'blob'
      });
@@ -110,25 +110,25 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
      const { result: paramsResult } = renderHook(() => useConvertParameters(), {
        wrapper: TestWrapper
      });
-      
+
      const { result: operationResult } = renderHook(() => useConvertOperation(), {
        wrapper: TestWrapper
      });
-      
+
      // Create mock unknown file
      const unknownFile = new File(['unknown content'], 'document.xyz', { type: 'application/octet-stream' });
-      
+
      // Test auto-detection
      act(() => {
        paramsResult.current.analyzeFileTypes([unknownFile]);
      });
-      
+
      await waitFor(() => {
        expect(paramsResult.current.parameters.fromExtension).toBe('file-xyz');
        expect(paramsResult.current.parameters.toExtension).toBe('pdf'); // Fallback
        expect(paramsResult.current.parameters.isSmartDetection).toBe(false);
      });
-      
+
      // Test conversion operation
      await act(async () => {
        await operationResult.current.executeOperation(
@@ -136,7 +136,7 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
          [unknownFile]
        );
      });
-      
+
      expect(mockedAxios.post).toHaveBeenCalledWith('/api/v1/convert/file/pdf', expect.any(FormData), {
        responseType: 'blob'
      });
@@ -144,35 +144,35 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
  });

  describe('Multi-File Smart Detection Flow', () => {
-    
+
    test('should detect all images and use img-to-pdf endpoint', async () => {
      const { result: paramsResult } = renderHook(() => useConvertParameters(), {
        wrapper: TestWrapper
      });
-      
+
      const { result: operationResult } = renderHook(() => useConvertOperation(), {
        wrapper: TestWrapper
      });
-      
+
      // Create mock image files
      const imageFiles = [
        new File(['jpg content'], 'photo1.jpg', { type: 'image/jpeg' }),
        new File(['png content'], 'photo2.png', { type: 'image/png' }),
        new File(['gif content'], 'photo3.gif', { type: 'image/gif' })
      ];
-      
+
      // Test smart detection for all images
      act(() => {
        paramsResult.current.analyzeFileTypes(imageFiles);
      });
-      
+
      await waitFor(() => {
        expect(paramsResult.current.parameters.fromExtension).toBe('image');
        expect(paramsResult.current.parameters.toExtension).toBe('pdf');
        expect(paramsResult.current.parameters.isSmartDetection).toBe(true);
        expect(paramsResult.current.parameters.smartDetectionType).toBe('images');
      });
-      
+
      // Test conversion operation
      await act(async () => {
        await operationResult.current.executeOperation(
@@ -180,13 +180,13 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
          imageFiles
        );
      });
-      
+
      expect(mockedAxios.post).toHaveBeenCalledWith('/api/v1/convert/img/pdf', expect.any(FormData), {
        responseType: 'blob'
      });
-      
+
      // Should send all files in single request
-      const formData = mockedAxios.post.mock.calls[0][1] as FormData;
+      const formData = (mockedAxios.post as Mock).mock.calls[0][1] as FormData;
      const files = formData.getAll('fileInput');
      expect(files).toHaveLength(3);
    });
@@ -195,30 +195,30 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
      const { result: paramsResult } = renderHook(() => useConvertParameters(), {
        wrapper: TestWrapper
      });
-      
+
      const { result: operationResult } = renderHook(() => useConvertOperation(), {
        wrapper: TestWrapper
      });
-      
+
      // Create mixed file types
      const mixedFiles = [
        new File(['pdf content'], 'document.pdf', { type: 'application/pdf' }),
        new File(['docx content'], 'spreadsheet.xlsx', { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' }),
        new File(['pptx content'], 'presentation.pptx', { type: 'application/vnd.openxmlformats-officedocument.presentationml.presentation' })
      ];
-      
+
      // Test smart detection for mixed types
      act(() => {
        paramsResult.current.analyzeFileTypes(mixedFiles);
      });
-      
+
      await waitFor(() => {
        expect(paramsResult.current.parameters.fromExtension).toBe('any');
        expect(paramsResult.current.parameters.toExtension).toBe('pdf');
        expect(paramsResult.current.parameters.isSmartDetection).toBe(true);
        expect(paramsResult.current.parameters.smartDetectionType).toBe('mixed');
      });
-      
+
      // Test conversion operation
      await act(async () => {
        await operationResult.current.executeOperation(
@@ -226,7 +226,7 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
          mixedFiles
        );
      });
-      
+
      expect(mockedAxios.post).toHaveBeenCalledWith('/api/v1/convert/file/pdf', expect.any(FormData), {
        responseType: 'blob'
      });
@@ -236,29 +236,29 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
      const { result: paramsResult } = renderHook(() => useConvertParameters(), {
        wrapper: TestWrapper
      });
-      
+
      const { result: operationResult } = renderHook(() => useConvertOperation(), {
        wrapper: TestWrapper
      });
-      
+
      // Create mock web files
      const webFiles = [
        new File(['<html>content</html>'], 'page1.html', { type: 'text/html' }),
        new File(['zip content'], 'site.zip', { type: 'application/zip' })
      ];
-      
+
      // Test smart detection for web files
      act(() => {
        paramsResult.current.analyzeFileTypes(webFiles);
      });
-      
+
      await waitFor(() => {
        expect(paramsResult.current.parameters.fromExtension).toBe('html');
        expect(paramsResult.current.parameters.toExtension).toBe('pdf');
        expect(paramsResult.current.parameters.isSmartDetection).toBe(true);
        expect(paramsResult.current.parameters.smartDetectionType).toBe('web');
      });
-      
+
      // Test conversion operation
      await act(async () => {
        await operationResult.current.executeOperation(
@@ -266,29 +266,29 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
          webFiles
        );
      });
-      
+
      expect(mockedAxios.post).toHaveBeenCalledWith('/api/v1/convert/html/pdf', expect.any(FormData), {
        responseType: 'blob'
      });
-      
+
      // Should process files separately for web files
      expect(mockedAxios.post).toHaveBeenCalledTimes(2);
    });
  });

  describe('Web and Email Conversion Options Integration', () => {
-    
+
    test('should send correct HTML parameters for web-to-pdf conversion', async () => {
      const { result: paramsResult } = renderHook(() => useConvertParameters(), {
        wrapper: TestWrapper
      });
-      
+
      const { result: operationResult } = renderHook(() => useConvertOperation(), {
        wrapper: TestWrapper
      });
-      
+
      const htmlFile = new File(['<html>content</html>'], 'page.html', { type: 'text/html' });
-      
+
      // Set up HTML conversion parameters
      act(() => {
        paramsResult.current.analyzeFileTypes([htmlFile]);
@@ -296,15 +296,15 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
          zoomLevel: 1.5
        });
      });
-      
+
      await act(async () => {
        await operationResult.current.executeOperation(
          paramsResult.current.parameters,
          [htmlFile]
        );
      });
-      
-      const formData = mockedAxios.post.mock.calls[0][1] as FormData;
+
+      const formData = (mockedAxios.post as Mock).mock.calls[0][1] as FormData;
      expect(formData.get('zoom')).toBe('1.5');
    });

@@ -312,13 +312,13 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
      const { result: paramsResult } = renderHook(() => useConvertParameters(), {
        wrapper: TestWrapper
      });
-      
+
      const { result: operationResult } = renderHook(() => useConvertOperation(), {
        wrapper: TestWrapper
      });
-      
+
      const emlFile = new File(['email content'], 'email.eml', { type: 'message/rfc822' });
-      
+
      // Set up email conversion parameters
      act(() => {
        paramsResult.current.updateParameter('fromExtension', 'eml');
@@ -330,15 +330,15 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
          includeAllRecipients: true
        });
      });
-      
+
      await act(async () => {
        await operationResult.current.executeOperation(
          paramsResult.current.parameters,
          [emlFile]
        );
      });
-      
-      const formData = mockedAxios.post.mock.calls[0][1] as FormData;
+
+      const formData = (mockedAxios.post as Mock).mock.calls[0][1] as FormData;
      expect(formData.get('includeAttachments')).toBe('false');
      expect(formData.get('maxAttachmentSizeMB')).toBe('20');
      expect(formData.get('downloadHtml')).toBe('true');
@@ -349,13 +349,13 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
      const { result: paramsResult } = renderHook(() => useConvertParameters(), {
        wrapper: TestWrapper
      });
-      
+
      const { result: operationResult } = renderHook(() => useConvertOperation(), {
        wrapper: TestWrapper
      });
-      
+
      const pdfFile = new File(['pdf content'], 'document.pdf', { type: 'application/pdf' });
-      
+
      // Set up PDF/A conversion parameters
      act(() => {
        paramsResult.current.updateParameter('fromExtension', 'pdf');
@@ -364,15 +364,15 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
          outputFormat: 'pdfa'
        });
      });
-      
+
      await act(async () => {
        await operationResult.current.executeOperation(
          paramsResult.current.parameters,
          [pdfFile]
        );
      });
-      
-      const formData = mockedAxios.post.mock.calls[0][1] as FormData;
+
+      const formData = (mockedAxios.post as Mock).mock.calls[0][1] as FormData;
      expect(formData.get('outputFormat')).toBe('pdfa');
      expect(mockedAxios.post).toHaveBeenCalledWith('/api/v1/convert/pdf/pdfa', expect.any(FormData), {
        responseType: 'blob'
@@ -381,21 +381,21 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
  });

  describe('Image Conversion Options Integration', () => {
-    
+
    test('should send correct parameters for image-to-pdf conversion', async () => {
      const { result: paramsResult } = renderHook(() => useConvertParameters(), {
        wrapper: TestWrapper
      });
-      
+
      const { result: operationResult } = renderHook(() => useConvertOperation(), {
        wrapper: TestWrapper
      });
-      
+
      const imageFiles = [
        new File(['jpg1'], 'photo1.jpg', { type: 'image/jpeg' }),
        new File(['jpg2'], 'photo2.jpg', { type: 'image/jpeg' })
      ];
-      
+
      // Set up image conversion parameters
      act(() => {
        paramsResult.current.analyzeFileTypes(imageFiles);
@@ -408,15 +408,15 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
          combineImages: true
        });
      });
-      
+
      await act(async () => {
        await operationResult.current.executeOperation(
          paramsResult.current.parameters,
          imageFiles
        );
      });
-      
-      const formData = mockedAxios.post.mock.calls[0][1] as FormData;
+
+      const formData = (mockedAxios.post as Mock).mock.calls[0][1] as FormData;
      expect(formData.get('fitOption')).toBe('fitToPage');
      expect(formData.get('colorType')).toBe('grayscale');
      expect(formData.get('autoRotate')).toBe('false');
@@ -426,16 +426,16 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
      const { result: paramsResult } = renderHook(() => useConvertParameters(), {
        wrapper: TestWrapper
      });
-      
+
      const { result: operationResult } = renderHook(() => useConvertOperation(), {
        wrapper: TestWrapper
      });
-      
+
      const imageFiles = [
        new File(['jpg1'], 'photo1.jpg', { type: 'image/jpeg' }),
        new File(['jpg2'], 'photo2.jpg', { type: 'image/jpeg' })
      ];
-      
+
      // Set up for separate processing
      act(() => {
        paramsResult.current.analyzeFileTypes(imageFiles);
@@ -444,55 +444,55 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
          combineImages: false
        });
      });
-      
+
      await act(async () => {
        await operationResult.current.executeOperation(
          paramsResult.current.parameters,
          imageFiles
        );
      });
-      
+
      // Should make separate API calls for each file
      expect(mockedAxios.post).toHaveBeenCalledTimes(2);
    });
  });

  describe('Error Scenarios in Smart Detection', () => {
-    
+

    test('should handle partial failures in multi-file processing', async () => {
      const { result: paramsResult } = renderHook(() => useConvertParameters(), {
        wrapper: TestWrapper
      });
-      
+
      const { result: operationResult } = renderHook(() => useConvertOperation(), {
        wrapper: TestWrapper
      });
-       
+
      // Mock one success, one failure
-      mockedAxios.post
+      (mockedAxios.post as Mock)
        .mockResolvedValueOnce({
          data: new Blob(['converted1'], { type: 'application/pdf' })
        })
        .mockRejectedValueOnce(new Error('File 2 failed'));
-      
+
      const mixedFiles = [
        new File(['file1'], 'doc1.txt', { type: 'text/plain' }),
        new File(['file2'], 'doc2.xyz', { type: 'application/octet-stream' })
      ];
-      
+
      // Set up for separate processing (mixed smart detection)
      act(() => {
        paramsResult.current.analyzeFileTypes(mixedFiles);
      });
-      
+
      await act(async () => {
        await operationResult.current.executeOperation(
          paramsResult.current.parameters,
          mixedFiles
        );
      });
-      
+
      await waitFor(() => {
        // Should have processed at least one file successfully
        expect(operationResult.current.files.length).toBeGreaterThan(0);
@@ -502,12 +502,12 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
  });

  describe('Real File Extension Detection', () => {
-    
+
    test('should correctly detect various file extensions', async () => {
      const { result } = renderHook(() => useConvertParameters(), {
        wrapper: TestWrapper
      });
-      
+
      const testCases = [
        { filename: 'document.PDF', expected: 'pdf' },
        { filename: 'image.JPEG', expected: 'jpg' }, // JPEG should normalize to jpg
@@ -517,11 +517,11 @@ describe('Convert Tool - Smart Detection Integration Tests', () => {
        { filename: '.hidden', expected: 'hidden' },
        { filename: 'noextension', expected: '' }
      ];
-      
+
      testCases.forEach(({ filename, expected }) => {
        const detected = detectFileExtension(filename);
        expect(detected).toBe(expected);
      });
    });
  });
-});
+});