import { type RiskLabel } from "../../../core/index.js";
import { type UIMessage } from "ai";
import type { MorphToastProps } from "../morph-toast.js";
import { type ApprovalWireMeta } from "./message-data.js";
/** One stream part in a turn: text (user verbatim / assistant markdown with the
    ENG-217 caret choreography), assistant files, tool build beats, and the
    generated-view app card (06-apps §§8–9). */
export declare function ThreadPart({ part, partKey, role, restored, count, risks, connectLive, hideBeats, turnPending, turnLive, sendMessage, siblingParts, respond }: {
    part: UIMessage["parts"][number];
    partKey: string;
    role: UIMessage["role"];
    restored: boolean;
    count?: number;
    risks: Map<string, RiskLabel>;
    /** Spec §1 — the settled turn folded its beats into the summary row (see
        ThreadMessage), so successful calls render nothing until it reopens. */
    hideBeats?: boolean;
    /** Spec §8 + §15 — whether this turn is still working. A view whose payload
        is STILL `streaming` once the turn is over is a build that died: nothing
        will ever flip it to ready. Defaults to pending so a part rendered on its
        own (or by a host composing its own list) keeps today's behavior. */
    turnPending?: boolean;
    /** Spec §8 — whether this turn is RUNNING, which is not the same question:
        `stop()` leaves the aborted call in `input-available`, so a stopped build
        reads as pending forever and its empty card would sweep forever with it.
        Defaults to `turnPending` for a part rendered on its own. */
    turnLive?: boolean;
    /** Whether a connect-required outcome in this turn is still the actionable
        ask (this is the LATEST assistant turn). Stale turns render the quiet
        Connected record instead — see ConnectCard's `live`. */
    connectLive?: boolean;
    /** The thread's send, for the post-connect continuation. */
    sendMessage?: (message: {
        text: string;
    }) => unknown;
    /** The enclosing message's parts — the grant-set card reads its parked
        native call's state from the sibling tool part (same toolCallId). */
    siblingParts?: UIMessage["parts"];
    /** The thread's native approval response — the grant-set card resumes the
        parked turn with it after deciding the guard set over the wire. */
    respond?: (response: {
        id: string;
        approved: boolean;
    }) => void;
}): import("react").JSX.Element | null;
type ToolPart = Extract<UIMessage["parts"][number], {
    toolCallId: string;
}>;
/** The parked in-thread approval cards: each builds its ApprovalRequest with
    the shared §16 wire builder (ENG-216), morphs into the top-right toast on
    approve (ENG-205), and decides the guard's record over the wire before resuming
    the model loop (05 §1). */
export declare function ThreadApprovals({ approvals, risks, guardApprovals, cardRefs, respond, onMorph }: {
    approvals: (ToolPart & {
        state: "approval-requested";
        approval: {
            id: string;
        };
    })[];
    risks: Map<string, RiskLabel>;
    guardApprovals: Map<string, ApprovalWireMeta>;
    cardRefs: React.MutableRefObject<Map<string, HTMLDivElement | null>>;
    respond: (response: {
        id: string;
        approved: boolean;
    }) => void;
    onMorph: (morph: Omit<MorphToastProps, "onDone">) => void;
}): import("react").JSX.Element;
export {};