/**
 * Whether the project declares native modules of its own.
 *
 * `blueprint-only` is a description, not a verdict: see the module comment.
 */
export type ProjectKind = "code" | "blueprint-only";
/** The I/O the toolchain probe does, injectable so it can be tested. */
export interface ProbeHooks {
    platform: NodeJS.Platform;
    env: NodeJS.ProcessEnv;
    exists(candidate: string): boolean;
    /** Trimmed stdout, or null when the command is absent or fails. */
    run(command: string, args: string[]): string | null;
}
export declare const DEFAULT_PROBE_HOOKS: ProbeHooks;
export interface ToolchainReport {
    present: boolean;
    /** What was found, named the way the installer names it. */
    name: string | null;
    detail?: string;
    /** Every location consulted, so a miss is diagnosable rather than a shrug. */
    probed: string[];
    /** The exact thing to install when nothing was found. */
    fix?: string;
}
/**
 * The C++ toolchain Unreal compiles a plugin with, on this machine.
 *
 * Deliberately does not probe .NET: every engine install ships its own dotnet
 * under `Engine/Binaries/ThirdParty/DotNet`, and UnrealBuildTool uses that one.
 */
export declare function detectToolchain(hooks?: ProbeHooks): ToolchainReport;
/** What a .uproject declares about its own native code. */
export interface ProjectShape {
    kind: ProjectKind;
    hasSourceDir: boolean;
    /** Module names from the .uproject's Modules array. */
    declaredModules: string[];
    /** Plugin names the .uproject enables, so the bridge can be looked for. */
    enabledPlugins: string[];
    bridgeEnabled: boolean;
}
export declare function readProjectShape(uprojectPath: string): ProjectShape;
export interface InstallProblem {
    /** Stable identifier, so a caller can branch without matching prose. */
    code: "no_engine" | "no_toolchain" | "bridge_not_deployed" | "bridge_not_enabled" | "bridge_never_compiled" | "bridge_build_stale" | "bridge_version_mismatch";
    what: string;
    fix: string;
}
export interface InstallReport {
    ok: boolean;
    project: {
        path: string;
        name: string;
        kind: ProjectKind;
        hasSourceDir: boolean;
        declaredModules: string[];
        /** Why a Blueprint-only project is still installable, when it is one. */
        note?: string;
    };
    engine: {
        resolved: boolean;
        root: string | null;
        source: string | null;
        buildTool: string | null;
    };
    bridge: {
        deployed: boolean;
        enabledInUproject: boolean;
        packagedVersion: string | null;
        installedVersion: string | null;
        versionMatch: boolean | null;
        compiled: boolean;
        binaryPath?: string;
        stale: boolean;
    };
    toolchain: ToolchainReport;
    problems: InstallProblem[];
    /** The ordered calls that take this project from here to a working bridge. */
    nextSteps: string[];
}
export interface InspectInstallOptions {
    hooks?: ProbeHooks;
    /** Skip the toolchain probe, which shells out. Used by callers that only
     *  want the on-disk half. */
    skipToolchain?: boolean;
}
/**
 * Everything standing between this .uproject and a bridge that answers.
 *
 * Reads only: it never deploys, enables, or builds anything. The steps it
 * returns are the calls that would.
 */
export declare function inspectInstall(uprojectPath: string, options?: InspectInstallOptions): InstallReport;
/**
 * The one-paragraph version, for a CLI that has just finished deploying.
 *
 * Returns null when there is nothing to warn about, so a healthy install still
 * ends on "Setup complete!" and nothing else.
 */
export declare function installWarning(report: InstallReport): string | null;