/**
 * IntegrationVerifier — deterministic wiring checks for generated applications.
 *
 * Catches five classes of integration failure that compile clean but don't work:
 *   1. Missing Router provider (pages use react-router hooks but no Router wraps them)
 *   2. Missing IPC handlers (preload invokes channels with no main-process handler)
 *   3. Stub functions (async functions that return literal objects without doing real work)
 *   4. Unreachable pages (page files exist but are never imported from the entry point)
 *   5. Response shape mismatch (handler wraps in {success, data} but preload doesn't unwrap)
 *
 * Zero LLM calls. Deterministic. Uses only node:fs/promises, node:path, and regex.
 */
import type { IntegrationCheck, IntegrationVerificationResult } from './types.js';
export declare class IntegrationVerifier {
    private readonly projectPath;
    private readonly framework;
    constructor(projectPath: string, framework: string);
    verify(): Promise<IntegrationVerificationResult>;
    /**
     * Scan all .tsx files for react-router hook usage.
     * If found, verify a Router provider exists in the entry point chain.
     */
    checkRoutingProvider(): Promise<IntegrationCheck[]>;
    /**
     * Electron only. Scan preload files for ipcRenderer.invoke calls.
     * Scan main/ipc files for ipcMain.handle calls.
     * Report any channel invoked but not handled.
     */
    checkIpcHandlerCoverage(): Promise<IntegrationCheck[]>;
    /**
     * Find async functions in preload whose body is ONLY a return of a literal object
     * without ipcRenderer.invoke, await, .query(), or fetch().
     */
    checkStubFunctions(): Promise<IntegrationCheck[]>;
    /**
     * Collect page files from pages/ directories.
     * Build import graph from entry point.
     * Report any page file not transitively imported.
     */
    checkUnreachablePages(): Promise<IntegrationCheck[]>;
    /**
     * Electron only. Cross-reference preload invoke handling against handler return shapes.
     * Detects the mismatch where a handler wraps its response in { success, data }
     * but the preload passes the raw IPC result through without unwrapping .data.
     * This causes renderer code to access result.rows when actual data is at result.data.rows.
     */
    checkResponseShapeConsistency(): Promise<IntegrationCheck[]>;
    /** Check if the project has preload files (indicating Electron). */
    private hasPreloadFiles;
    /**
     * Detect which catalog framework tags apply to this project.
     * Combines the constructor-provided framework with package.json dependency scanning.
     */
    private detectCatalogFrameworks;
}