/**
 * TradeoffResolver — deterministic tie-breaker for two contending values per
 * the org's `tradeoffHierarchy` from `ORG-INTENT.md`.
 *
 * Phase 3 of the ORG-INTENT runtime project. Phase 1 wired the gate; Phase 2
 * injected the contract at session-start; Phase 3 makes the tradeoff hierarchy
 * mechanically consultable by any caller — research agents, planning paths,
 * the value-alignment reviewer itself when it sees a values collision.
 *
 * The resolver is pure logic over the parsed hierarchy. It does not make value
 * judgments; it does not call an LLM. Given two value strings (e.g. "speed" and
 * "trust") and the hierarchy list, it returns which one wins, the basis for
 * the decision, and an explanation that callers can surface to users or LLMs.
 *
 * Match strategy (in order):
 *   1. **Pair-pattern match**: hierarchy entries written as "X over Y" or
 *      "X before Y" or "X above Y" — if both arguments match X and Y, the
 *      stated winner is returned regardless of list position.
 *   2. **List-order match**: each argument is matched against hierarchy entries
 *      via case-insensitive substring containment. The argument whose match
 *      lands at the EARLIEST index wins.
 *   3. **No match**: neither argument is found in the hierarchy → null winner,
 *      basis = 'no-match'. Caller decides what to do (typically: ask the LLM,
 *      or fall back to value-alignment review).
 */
export interface TradeoffResolution {
    /** Which input wins. null when no hierarchy entry decides. */
    winner: 'A' | 'B' | null;
    /** Why the resolver chose that outcome. */
    basis: 'pair-pattern' | 'list-order' | 'no-match' | 'tie';
    /** Human-readable explanation. Safe to surface to users or LLMs. */
    explanation: string;
    /** Index in the hierarchy that matched A (if any). -1 if unmatched. */
    matchedIndexA: number;
    /** Index in the hierarchy that matched B (if any). -1 if unmatched. */
    matchedIndexB: number;
}
export interface TradeoffResolutionInput {
    valueA: string;
    valueB: string;
    hierarchy: string[];
}
/**
 * Resolve a tradeoff between two values per the organizational hierarchy.
 *
 * @param input.valueA First contending value (free-text, e.g. "speed").
 * @param input.valueB Second contending value (free-text, e.g. "customer trust").
 * @param input.hierarchy Ordered list of hierarchy entries from `ORG-INTENT.md`.
 *   May be a plain ranked list (`["customer trust", "speed"]`) or use "X over Y"
 *   pair patterns (`["customer trust over speed"]`) or any mix.
 * @returns A resolution stating which input wins and why.
 */
export declare function resolveTradeoff(input: TradeoffResolutionInput): TradeoffResolution;
//# sourceMappingURL=TradeoffResolver.d.ts.map