/**
 * detect-amplitude — Static heuristics to check if Amplitude is already
 * installed in the project directory, without calling any APIs or AI.
 *
 * Checks (in order of confidence):
 *   1. package.json — Amplitude npm packages in dependencies
 *   2. Python requirements files — amplitude-analytics
 *   3. Swift — Podfile or Package.resolved
 *   4. Android / Java — build.gradle / build.gradle.kts
 *   5. Flutter — pubspec.yaml
 *   6. Go — go.mod
 *   7. Unreal Engine — Config/DefaultEngine.ini or Plugins/AmplitudeUnreal/
 *   8. Unity — Packages/manifest.json
 *   9. Source code imports — grep for amplitude import statements
 *
 * Returns a confidence level so callers can decide how to act:
 *   'high'   — package file explicitly lists an Amplitude SDK
 *   'low'    — import found in source but no package file entry
 *   'none'   — no evidence found
 */
export type AmplitudeDetectionConfidence = 'high' | 'low' | 'none';
export interface AmplitudeDetectionResult {
    confidence: AmplitudeDetectionConfidence;
    /** Human-readable reason for the confidence level */
    reason: string | null;
}
/**
 * Run all static checks in priority order.
 * Returns the first non-'none' result, or 'none' if nothing found.
 */
export declare function detectAmplitudeInProject(installDir: string): AmplitudeDetectionResult;
/**
 * Source-only Amplitude detection — ignores package.json / lockfile metadata
 * and only searches actual source code for an Amplitude import statement.
 *
 * Use this to corroborate that the SDK is *wired up*, not just installed.
 * Distinguishes "the dep is in package.json but no file actually imports it"
 * (stale install) from "the SDK is actually being used at runtime".
 *
 * Returns 'low' on a hit (because grepping source is intrinsically a weaker
 * signal than a package-file declaration), or 'none' if nothing imports
 * Amplitude anywhere under `installDir`.
 */
export declare function detectAmplitudeInProjectSource(installDir: string): AmplitudeDetectionResult;
/**
 * Per-signal breakdown of "is this project fully wired up?". Used by the
 * Activation Check pre-flight to decide whether a re-run can skip the agent
 * loop entirely. Each boolean is a hard yes/no on a single local artifact:
 *
 *   - `dependency`     — Amplitude SDK declared in package.json /
 *                        requirements / Podfile / build.gradle / etc.
 *                        (the same checks `detectAmplitudeInProject` runs).
 *   - `sourceImport`   — at least one source file actually imports the SDK
 *                        and uses it (`detectAmplitudeInProjectSource`).
 *   - `ampliConfig`    — `ampli.json` exists with a non-empty OrgId AND
 *                        ProjectId (so the next run can recover scope
 *                        without re-prompting).
 *   - `eventPlan`      — `.amplitude/events.json` (or root-level
 *                        `.amplitude-events.json`) exists and is
 *                        non-empty array — i.e. the user has already
 *                        approved an event plan.
 *
 * Returns `fullyWired` true when ALL four signals are present. `present`
 * and `missing` lists let the caller log exactly why the short-circuit
 * fired or didn't (useful for triaging "but I had it set up!" reports).
 */
export interface FullyWiredCheck {
    fullyWired: boolean;
    signals: {
        dependency: boolean;
        sourceImport: boolean;
        ampliConfig: boolean;
        eventPlan: boolean;
    };
    /** Names of signals that PASSED — for log/UI summary. */
    present: string[];
    /** Names of signals that FAILED — for log/UI summary. */
    missing: string[];
}
/**
 * Pre-flight check used by the Activation flow: are all four local
 * "this project was fully set up by a prior wizard run" signals present?
 *
 * When the answer is yes, the wizard can short-circuit past the agent loop
 * (Setup + Run screens) and route directly to the ingestion poll — re-runs
 * on already-instrumented projects no longer waste 2-3 minutes re-running
 * the agent on a no-op. The remote-events check that drives `'full'` still
 * runs INSIDE DataIngestionCheckScreen on its own polling cadence; this
 * function only governs whether the agent loop runs at all.
 *
 * Pure function over the filesystem; no API calls, no side-effects. Safe
 * to call from synchronous render paths.
 */
export declare function isProjectFullyWired(installDir: string): FullyWiredCheck;
