/** The base class of every error this package throws. */
export declare class RuntimeSdkError extends Error {
    constructor(message: string, options?: {
        cause?: unknown;
    });
}
/**
 * The door was given an input only the HOST can correct (WS-23: it was first the official leg's —
 * "something only the host can supply was missing" — and is now the Winter door's: a capability-name
 * collision, a selection naming the retired official runtime, a missing home).
 *
 * WHY ITS OWN CLASS RATHER THAN `OfficialConfigurationError`. That class is WS-14 §13's, and it is
 * about an options object that is wrong — a field this branch refuses, a combination the runtime
 * cannot run. This one is about the DOOR's own inputs: the session id its directory row is addressed
 * by, the credential its auth family needs, the vendored runtime path §5.1 will not guess. A host
 * catching it knows to fix a call site, not a configuration.
 *
 * THE PREFIX IS LEG-NEUTRAL, AND IT HAD TO BECOME SO (interim review I-7). It read "the official leg
 * needs `<field>`" for as long as the official leg was the only caller — and then R-8 gave the class
 * three refusals that are not: `capabilities` at CONSTRUCTION (before any leg exists, and fatal to a
 * Winter-only host), and `mcpServers` on the WINTER leg. A host with no official peer at all reading
 * "the official leg needs `mcpServers`" is told to look at the one branch it does not use. `leg` names
 * the branch when there IS one, so nothing is lost where the old sentence was right.
 */
export declare class RuntimeLaunchInputError extends RuntimeSdkError {
    readonly field: string;
    constructor(args: {
        field: string;
        reason: string;
        leg?: "official" | "winter";
    });
}
/**
 * A directory row whose address the router cannot name — refused at the door rather than listed.
 *
 * WHY IT IS AN ERROR AND NOT A DROPPED ROW (review r4, NEW-13). Every row the directory holds is
 * shown to a model by `ListAgents` and is then expected to answer `SendMessage`. An address that does
 * not parse fails all three resolution doors — by the listed string, by its canonicalised form, and
 * by `deliver()` on the row's own address — so the listing advertises an object nothing can reach and
 * no error explains why. A LISTED OBJECT IS ALWAYS ADDRESSABLE; the writer is an adapter recording a
 * launch, and the fix is always one line at the call site, so it is told.
 *
 * SPINE-OWNED because two lanes throw it: the directory's `record()` door and the official adapter's
 * default record sink, which is where the non-canonical address actually came from.
 */
export declare class UnaddressableEntryError extends RuntimeSdkError {
    readonly address: string;
    constructor(address: string);
}
/**
 * D19a: the injected peers are outside the tested compatibility matrix, so construction refuses.
 *
 * `expected`/`actual` are the two fields the plan pins. They are STRINGS, not objects, because the
 * one thing a host does with them is print them: `expected` is the matrix entry that was violated
 * (`"@yanlinglabs/winter-agent-sdk >=0.0.2 <0.1.0"`), `actual` is what the injected peer reported
 * (`"0.0.1"`, or `"unknown (the injected module exports no version identity and no installed copy
 * could be resolved)"`).
 */
export declare class RuntimeSdkVersionError extends RuntimeSdkError {
    readonly expected: string;
    readonly actual: string;
    constructor(args: {
        expected: string;
        actual: string;
        message?: string;
    });
}
/** Which lane of Phase 7b owns a seam that is declared but not yet implemented. */
export type LaneId = "lane-a" | "lane-b" | "lane-c" | "lane-d";
/**
 * A seam the spine pinned and a lane has not landed yet.
 *
 * DELIBERATELY A THROW, not a silent no-op or a plausible default. The spine's whole job is to let
 * four lanes build against final signatures in parallel; a stub that returned something shaped right
 * would let a lane (or a host) build on an answer nobody computed, and the failure would surface as
 * wrong behaviour somewhere else. The lane id is a field, not just prose, so a test can assert WHICH
 * seam is still open (`test/spine/seams.test.ts` does exactly that) and so a close-out check can
 * enumerate the remaining ones.
 */
export declare class NotImplementedYet extends RuntimeSdkError {
    readonly lane: LaneId;
    readonly seam: string;
    constructor(lane: LaneId, seam: string);
}
/** A `RuntimeSdk` method called after `dispose()`. */
export declare class RuntimeSdkDisposedError extends RuntimeSdkError {
    constructor(method: string);
}