/**
 * The {@link ScopePlanner} — a fluent, immutable builder that decides which
 * toolkits and tools are in scope for a hydration or discovery request.
 *
 * The thing this replaces was a priority cascade: a method that looked at an
 * options bag and, through a chain of `if` branches, picked "explicit tool slugs,
 * else the toolkit union, else the auth-config set, else throw." That structure is
 * both hard to read and easy to fingerprint. Here the decision is expressed as
 * *accumulated intent* instead: the caller declares what they want
 * (`.include(toolkit)`, `.only(toolNames)`), and a single {@link ScopePlanner.plan}
 * step resolves that intent into one of three explicit {@link ScopeKind} shapes —
 * `byTools`, `byToolkits`, or `empty` — with no nested branching.
 *
 * Every mutator returns a *new* planner; the receiver is never changed. That makes
 * a planner safe to share, fork, and reuse as a base for several requests. The
 * builder holds only normalized data (deduped, trimmed); resolution into a
 * {@link ResolvedScope} happens once, at `plan()`.
 */
/**
 * The three resolved shapes a scope can take, discriminated by `kind`.
 *
 * - `byTools` — an explicit set of fully-qualified tool slugs (the most specific
 *   intent; toolkits are implied by the slugs and carried alongside for context).
 * - `byToolkits` — one or more whole toolkits, every tool in scope.
 * - `empty` — nothing was declared; the caller must treat this as "no scope".
 */
export type ResolvedScope = {
    readonly kind: "byTools";
    readonly tools: readonly string[];
    readonly toolkits: readonly string[];
} | {
    readonly kind: "byToolkits";
    readonly toolkits: readonly string[];
} | {
    readonly kind: "empty";
};
/** The discriminant tag of a {@link ResolvedScope}. */
export type ScopeKind = ResolvedScope["kind"];
/**
 * An immutable builder of connector scope.
 *
 * Construct one with {@link ScopePlanner.create}, narrow it with the fluent
 * mutators, and resolve it with {@link ScopePlanner.plan}. No mutator alters the
 * instance it is called on.
 */
export declare class ScopePlanner {
    private readonly toolkits;
    private readonly tools;
    private constructor();
    /** Start from an empty scope — nothing included, nothing pinned. */
    static create(): ScopePlanner;
    /**
     * Add one or more toolkits to the scope. Returns a new planner with those
     * toolkits unioned into the existing set; duplicates and blanks are dropped.
     */
    include(...toolkits: string[]): ScopePlanner;
    /**
     * Pin the scope to specific tool slugs. Returns a new planner whose tool set is
     * the union of the prior pinned tools and these. Pinned tools take precedence
     * over a bare toolkit list when the scope is resolved.
     */
    only(...toolNames: string[]): ScopePlanner;
    /** Whether anything at all has been declared. */
    isEmpty(): boolean;
    /**
     * Resolve the accumulated intent into one explicit {@link ResolvedScope}.
     *
     * Pinned tools win: if any were declared, the scope is `byTools` (carrying the
     * included toolkits as context). Otherwise, if toolkits were included, it is
     * `byToolkits`. With nothing declared the scope is `empty` — callers decide
     * whether that is an error in their context.
     */
    plan(): ResolvedScope;
}
