/**
 * A8: a `for` loop whose only body is an early return, followed by the return
 * that says what the loop did not find, is exactly one of three compiler-owned
 * List queries — `some`, `every`, `find`.
 *
 * D115 §三 / D114 R1f: this proof was the one member of the A roster left on
 * `Analyzer`, because it reads the walk's live depths — `functionDepth`,
 * `constructorDepth`, `finallyLoopDepths` — to know it is inside a function
 * body and not inside a `finally`. Those three are now live accessors on
 * `AdvisoryHost`, so the proof lives with the rest of the roster. The A8
 * documentation block below travelled with it: it had been left attached to
 * `analyzeImportDeclaration`, 800 lines from the method it describes.
 */
import { type Statement } from "../../ast.ts";
import { type AdvisoryHost } from "./roster.ts";
export declare class QueryAdvisories {
    private readonly host;
    constructor(host: AdvisoryHost);
    /**
     * A8: the exact early-return List queries have compiler-owned spellings:
     * `some`, `every`, and `find`. This is a proof, not a general loop-style
     * preference. The source is a plain List binding, the loop has one name
     * slot, and the predicate is a non-optional bool made only from data reads
     * and operators. A call or class member can hide a mutation/getter, and List
     * iteration is live while query methods snapshot their inputs, so either
     * shape keeps the expanded loop silent.
     */
    adviseManualListQuery(previous: Statement | null, statement: Statement): void;
    private isBooleanLiteralReturn;
    private isNullLiteralReturn;
    private isLoopSlotReturn;
    /**
     * Rebuilds only the expression subset whose evaluation cannot hide a call,
     * write, await, dynamic import, or class getter. Parenthesizing nested
     * operators preserves their AST grouping without needing the source text.
     */
    private manualListQueryPredicateSpelling;
}
//# sourceMappingURL=queries.d.ts.map