/**
 * Compose Multiplatform (CMP) capability detection (Principle 6).
 *
 * The candidate side is cheapest to render when the UI is Compose
 * Multiplatform: a CMP component renders on the JVM/desktop — and, increasingly,
 * a headless browser via Compose for Web / wasm — with no Android emulator. So
 * the bot *prefers* the CMP render path when a project supports it, and
 * *promotes* CMP to projects that don't. This module supplies the deterministic
 * half of that: scan committed Gradle build files for CMP signals and report a
 * `cmpCapable` verdict plus the evidence behind it.
 *
 * This is detection + advisory only. It NEVER gates: plain Jetpack Compose stays
 * fully supported, and a non-CMP repo gets a suggestion, not a failure
 * (Principle 6). Detection is a bounded, deterministic, offline file scan — no
 * model calls, no network, no toolchain — matching {@link detectMaturity}.
 */
/** What kind of CMP evidence a build file yielded. */
export type CmpSignalKind = 
/** The `org.jetbrains.compose` Gradle plugin (the CMP plugin). */
"compose-plugin"
/** The Kotlin Multiplatform plugin (`kotlin("multiplatform")` / KMP id). */
 | "kotlin-multiplatform"
/** A non-Android KMP target that can host a headless render (jvm/desktop/wasmJs/js). */
 | "jvm-target"
/** A `compose-multiplatform` dependency or version-catalog coordinate. */
 | "compose-dependency";
/** One piece of CMP evidence found in a build file. */
export interface CmpSignal {
    kind: CmpSignalKind;
    /** Repo-relative path to the build file that matched. */
    path: string;
    /** The literal text fragment that matched, for an auditable verdict. */
    match: string;
}
/** The CMP capability verdict, surfaced on the maturity result. */
export interface CmpCapability {
    /** True when any CMP signal was found (drives the prefer/promote choice). */
    cmpCapable: boolean;
    /** Every CMP signal found, in scan order — the audit trail. */
    signals: CmpSignal[];
}
/** True if `name` is a build file this module scans. */
export declare function isCmpBuildFile(name: string): boolean;
/**
 * Classify the contents of a single build file into CMP signals (pure).
 *
 * Comment lines (`//`, `#`) are skipped so a commented-out plugin block never
 * trips a false positive. At most one signal per kind per file is reported, so
 * the evidence stays compact.
 *
 * @param path repo-relative path, echoed back on each signal for the audit trail
 * @param contents the file's text
 */
export declare function classifyBuildFile(path: string, contents: string): CmpSignal[];
/**
 * Fold a set of per-file signals into a {@link CmpCapability} verdict.
 *
 * A repo is CMP-capable on *any* signal — the CMP plugin, the KMP plugin, a
 * JVM/desktop/wasm/js target, or a compose-multiplatform dependency. The
 * threshold is deliberately permissive: this is an advisory promote/prefer hint,
 * never a gate, so a false positive merely skips a suggestion and a false
 * negative merely shows one (Principle 6).
 */
export declare function summarizeCmp(signals: CmpSignal[]): CmpCapability;
/**
 * The promotion suggestion shown to Android-only (non-CMP) projects. Returns a
 * non-blocking advisory string when `capability.cmpCapable` is false, and
 * `undefined` when the repo is already CMP-capable (nothing to promote).
 *
 * This is the "promote CMP, never require it" half of Principle 6: advisory
 * only, surfaced in the bootstrap output and (where relevant) the PR comment —
 * never a gate.
 */
export declare function cmpSuggestion(capability: CmpCapability): string | undefined;
//# sourceMappingURL=cmp.d.ts.map