@threadplane/chat 0.0.46

package/types/threadplane-chat.d.ts

@@ -0,0 +1,2255 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, TemplateRef, Type, WritableSignal } from '@angular/core';
+import * as _threadplane_render from '@threadplane/render';
+import { AngularRegistry, RenderEvent, ViewRegistry, RenderViewEntry } from '@threadplane/render';
+export { VIEW_REGISTRY, ViewRegistry, provideViews, toRenderRegistry, views, withViews, withoutViews } from '@threadplane/render';
+import { Observable } from 'rxjs';
+import * as _json_render_core from '@json-render/core';
+import { Spec, StateStore } from '@json-render/core';
+import { A2uiComponentDef, A2uiSurface, A2uiMessage, A2uiActionMessage } from '@threadplane/a2ui';
+export { A2uiAction, A2uiActionContextEntry, A2uiActionMessage, A2uiChildren, A2uiClientDataModel, A2uiComponent, A2uiComponentDef, A2uiSurface, A2uiTheme, DynamicBoolean, DynamicNumber, DynamicString, isLiteralBoolean, isLiteralNumber, isLiteralString, isPathRef } from '@threadplane/a2ui';
+import { PartialJsonParser } from '@cacheplane/partial-json';
+import { BaseMessage } from '@langchain/core/messages';
+import * as _cacheplane_partial_markdown from '@cacheplane/partial-markdown';
+import { CitationDefinition, MarkdownDocumentNode, MarkdownNode, MarkdownParagraphNode, MarkdownHeadingNode, MarkdownBlockquoteNode, MarkdownListNode, MarkdownListItemNode, MarkdownCodeBlockNode, MarkdownThematicBreakNode, MarkdownTextNode, MarkdownEmphasisNode, MarkdownStrongNode, MarkdownStrikethroughNode, MarkdownInlineCodeNode, MarkdownLinkNode, MarkdownAutolinkNode, MarkdownImageNode, MarkdownSoftBreakNode, MarkdownHardBreakNode, MarkdownCitationReferenceNode, MarkdownTableNode, MarkdownTableRowNode, MarkdownTableCellNode } from '@cacheplane/partial-markdown';
+import * as _threadplane_chat from '@threadplane/chat';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+
+interface ChatConfig {
+    /** Shared render registry for consumers that read CHAT_CONFIG. */
+    renderRegistry?: AngularRegistry;
+    /** Shared AI avatar label for consumers that read CHAT_CONFIG (default: "A"). */
+    avatarLabel?: string;
+    /** Shared assistant display name for consumers that read CHAT_CONFIG (default: "Assistant"). */
+    assistantName?: string;
+    /** Signed license token from threadplane.ai. Optional; omitted in dev. */
+    license?: string;
+    /**
+     * @internal
+     * Test-only env hint override. Not part of the stable API.
+     */
+    __licenseEnvHint?: {
+        isNoncommercial: boolean;
+    };
+    /**
+     * @internal
+     * Test-only public-key override. Defaults to the compile-time embedded
+     * `LICENSE_PUBLIC_KEY`. Not part of the stable API.
+     */
+    __licensePublicKey?: Uint8Array;
+}
+declare const CHAT_CONFIG: InjectionToken<ChatConfig>;
+declare function provideChat(config: ChatConfig): _angular_core.EnvironmentProviders;
+
+type MessageTemplateType = 'human' | 'ai' | 'tool' | 'system' | 'function';
+
+type ContentBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    url: string;
+    alt?: string;
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    args: unknown;
+} | {
+    type: 'tool_result';
+    toolCallId: string;
+    result: unknown;
+    isError?: boolean;
+};
+
+/**
+ * Provider-agnostic citation entry. Populated by adapters from message
+ * metadata (LangGraph additional_kwargs.citations, ag-ui STATE_DELTA at
+ * /citations/{messageId}). Pandoc-formatted [^id]: ... defs in message
+ * content remain in the markdown AST sidecar and are merged via
+ * CitationsResolverService at render time.
+ */
+interface Citation {
+    /** Stable id used to match `[^id]` markers in Pandoc-formatted content. */
+    id: string;
+    /** 1-based display order. Stable per-message. */
+    index: number;
+    title?: string;
+    url?: string;
+    snippet?: string;
+    /** Provider-specific extras (retrieval score, source type, etc.). */
+    extra?: Record<string, unknown>;
+}
+
+type Role = 'user' | 'assistant' | 'system' | 'tool';
+interface Message {
+    id: string;
+    role: Role;
+    /** Plain text, or a list of structured content blocks. */
+    content: string | ContentBlock[];
+    /** Present when role === 'tool'. */
+    toolCallId?: string;
+    /** Optional display/author name. */
+    name?: string;
+    /**
+     * Reasoning text emitted by the model before/alongside the visible
+     * response. Populated by adapters from {type:'reasoning'} or
+     * {type:'thinking'} content blocks (LangGraph) or REASONING_MESSAGE_*
+     * events (AG-UI). Always a plain string — provider-specific shape
+     * (encrypted blocks, multi-step summaries) is absorbed by the adapter
+     * and not surfaced here.
+     */
+    reasoning?: string;
+    /**
+     * Wall-clock duration of the reasoning phase in milliseconds.
+     * Populated by the adapter when both start (first reasoning chunk) and
+     * end (first response-text chunk, or final canonical message) are
+     * known. Undefined when reasoning timing isn't available.
+     */
+    reasoningDurationMs?: number;
+    /** Runtime-specific extras; do not rely on shape in portable code. */
+    extra?: Record<string, unknown>;
+    /** Provider-agnostic citation list. Populated by adapters. */
+    citations?: Citation[];
+    /**
+     * IDs of tool calls emitted BY this assistant message. Populated by
+     * adapters from provider-native fields (LangGraph: `tool_calls[].id`;
+     * Anthropic: `tool_use` content blocks). Used by `<chat-tool-calls>` to
+     * scope its rendering to a single message — otherwise it falls back to
+     * the agent's global toolCalls list, which renders duplicates across
+     * every AI message in a thread.
+     */
+    toolCallIds?: string[];
+}
+declare function isUserMessage(m: Message): m is Message & {
+    role: 'user';
+};
+declare function isAssistantMessage(m: Message): m is Message & {
+    role: 'assistant';
+};
+declare function isToolMessage(m: Message): m is Message & {
+    role: 'tool';
+};
+declare function isSystemMessage(m: Message): m is Message & {
+    role: 'system';
+};
+
+type ToolCallStatus = 'pending' | 'running' | 'complete' | 'error';
+interface ToolCall {
+    id: string;
+    name: string;
+    /** Arguments. May be partial while streaming (`status !== 'complete'`). */
+    args: unknown;
+    status: ToolCallStatus;
+    /** Present when status === 'complete' or 'error'. */
+    result?: unknown;
+    /** Optional error payload when status === 'error'. */
+    error?: unknown;
+}
+
+type AgentStatus = 'idle' | 'running' | 'error';
+
+interface AgentInterrupt {
+    /** Stable identifier for this interrupt instance. */
+    id: string;
+    /** Opaque payload the app renders. Runtime-specific shape. */
+    value: unknown;
+    /** True when the runtime supports resuming via `submit({ resume })`. */
+    resumable: boolean;
+}
+
+type SubagentStatus = 'pending' | 'running' | 'complete' | 'error';
+interface Subagent {
+    /** Tool call ID that spawned this subagent. */
+    toolCallId: string;
+    /** Optional human-readable name. */
+    name?: string;
+    status: Signal<SubagentStatus>;
+    messages: Signal<Message[]>;
+    state: Signal<Record<string, unknown>>;
+}
+
+/**
+ * Render-state-store sync event. Adapters emit this when the runtime
+ * publishes a state-snapshot intended for the chat library's render store
+ * (used by generative UI and a2ui surfaces).
+ */
+interface AgentStateUpdateEvent {
+    readonly type: 'state_update';
+    readonly data: Record<string, unknown>;
+}
+/**
+ * Escape hatch for runtime-specific or user-defined events that do not
+ * (yet) have a well-known structured variant. `name` carries the runtime
+ * event name; `data` carries the payload verbatim.
+ */
+interface AgentCustomEvent {
+    readonly type: 'custom';
+    readonly name: string;
+    readonly data: unknown;
+}
+/**
+ * Discriminated union of events flowing on `Agent.events$`.
+ *
+ * Invariant: state lives on signals (`messages`, `status`, `toolCalls`,
+ * `state`, `interrupt`, `subagents`, `history`); events on `events$`
+ * carry only things that are not derivable from signals. New variants
+ * are added purely additively when patterns prove necessary.
+ */
+type AgentEvent = AgentStateUpdateEvent | AgentCustomEvent;
+
+interface AgentSubmitInput {
+    /** New user message to append. May be combined with `resume` and/or `state` in the same submit call. */
+    message?: string | ContentBlock[];
+    /** Resume payload for an active interrupt. */
+    resume?: unknown;
+    /** State patch to merge before submitting (runtime-interpreted). */
+    state?: Record<string, unknown>;
+}
+interface AgentSubmitOptions {
+    signal?: AbortSignal;
+}
+
+/**
+ * Runtime-neutral contract chat primitives consume.
+ *
+ * Implementations are produced by runtime adapters (e.g. a LangGraph or
+ * AG-UI adapter) or by user code for custom backends.
+ *
+ * `interrupt` and `subagents` are optional: runtimes that do not support these
+ * concepts should leave them undefined, and primitives that need them check
+ * presence and render a neutral fallback when absent.
+ *
+ * Invariant: state lives on signals; `events$` carries only things that are
+ * not derivable from signals.
+ */
+interface Agent {
+    messages: Signal<Message[]>;
+    status: Signal<AgentStatus>;
+    isLoading: Signal<boolean>;
+    error: Signal<unknown>;
+    toolCalls: Signal<ToolCall[]>;
+    state: Signal<Record<string, unknown>>;
+    submit: (input: AgentSubmitInput, opts?: AgentSubmitOptions) => Promise<void>;
+    stop: () => Promise<void>;
+    /**
+     * Discards the assistant message at the given index AND all messages after
+     * it, then re-runs the agent against the trimmed conversation tail. The
+     * preceding user message (at index - 1) is preserved and re-submitted as
+     * the agent's input. No new user message is added to the history.
+     *
+     * Throws if the message at `index` is not 'assistant' role, or if the
+     * agent is currently loading another response.
+     */
+    regenerate: (assistantMessageIndex: number) => Promise<void>;
+    interrupt?: Signal<AgentInterrupt | undefined>;
+    subagents?: Signal<Map<string, Subagent>>;
+    events$: Observable<AgentEvent>;
+}
+
+/**
+ * Runtime-neutral snapshot of a point in an agent's execution history.
+ *
+ * Consumed by time-travel / debug UIs. `id` is adapter-opaque — UIs emit
+ * it back to the parent app on replay/fork, and the parent app dispatches
+ * to the underlying runtime.
+ */
+interface AgentCheckpoint {
+    /** Adapter-opaque checkpoint identifier (e.g. LangGraph checkpoint_id). */
+    id?: string;
+    /** Human-friendly label for the checkpoint (e.g. next node name). */
+    label?: string;
+    /** State snapshot at this checkpoint. */
+    values: Record<string, unknown>;
+}
+
+/**
+ * Extension of Agent that exposes checkpoint history for time-travel UIs.
+ *
+ * Concrete adapters that record per-node checkpoints (e.g. LangGraph) should
+ * implement this. Pure request/response runtimes that don't have checkpoints
+ * should implement plain Agent.
+ */
+interface AgentWithHistory extends Agent {
+    history: Signal<AgentCheckpoint[]>;
+    /**
+     * Optional reactive map of `messageId → checkpointId`, computed by
+     * walking history once: for each checkpoint, find the most recent
+     * assistant message present in its `values.messages` and pair them.
+     * UIs use this to anchor inline checkpoint markers on each assistant
+     * turn. Missing on adapters that don't compute it.
+     */
+    messageCheckpoints?: Signal<ReadonlyMap<string, string>>;
+}
+
+type AgentRuntimeTelemetryEvent = 'ngaf:runtime_instance_created' | 'ngaf:runtime_request_created' | 'ngaf:stream_started' | 'ngaf:stream_ended' | 'ngaf:stream_errored';
+interface AgentRuntimeTelemetryProperties {
+    transport: 'langgraph' | 'ag-ui' | 'custom' | string;
+    surface?: string;
+    requestType?: string;
+    provider?: string;
+    model?: string;
+    durationMs?: number;
+    errorClass?: string;
+}
+interface AgentRuntimeTelemetryPayload {
+    event: AgentRuntimeTelemetryEvent;
+    properties: AgentRuntimeTelemetryProperties;
+}
+type AgentRuntimeTelemetrySink = (payload: AgentRuntimeTelemetryPayload) => void | Promise<void>;
+
+declare class MessageTemplateDirective {
+    readonly chatMessageTemplate: _angular_core.InputSignal<MessageTemplateType>;
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MessageTemplateDirective, "ng-template[chatMessageTemplate]", never, { "chatMessageTemplate": { "alias": "chatMessageTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Maps a {@link Message} to a {@link MessageTemplateType}.
+ * Exported as a standalone function so it can be unit-tested without DOM rendering.
+ */
+declare function getMessageType(message: Message): MessageTemplateType;
+declare class ChatMessageListComponent {
+    readonly agent: _angular_core.InputSignal<Agent>;
+    readonly messageTemplates: _angular_core.Signal<readonly MessageTemplateDirective[]>;
+    readonly messages: _angular_core.Signal<Message[]>;
+    readonly getMessageType: typeof getMessageType;
+    findTemplate(type: MessageTemplateType): MessageTemplateDirective | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatMessageListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatMessageListComponent, "chat-message-list", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; }, {}, ["messageTemplates"], never, true, never>;
+}
+
+type ChatMessageRole = 'user' | 'assistant' | 'system' | 'tool';
+declare class ChatMessageComponent {
+    readonly role: _angular_core.InputSignal<ChatMessageRole>;
+    readonly current: _angular_core.InputSignal<boolean>;
+    readonly streaming: _angular_core.InputSignal<boolean>;
+    readonly prevRole: _angular_core.InputSignal<ChatMessageRole | undefined>;
+    readonly message: _angular_core.InputSignal<Message | undefined>;
+    private readonly resolver;
+    constructor();
+    readonly currentStr: _angular_core.Signal<string>;
+    readonly streamingStr: _angular_core.Signal<string>;
+    readonly bodyClass: _angular_core.Signal<"chat-message__bubble" | "chat-message__assistant-body" | "chat-message__plain">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatMessageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatMessageComponent, "chat-message", never, { "role": { "alias": "role"; "required": true; "isSignal": true; }; "current": { "alias": "current"; "required": false; "isSignal": true; }; "streaming": { "alias": "streaming"; "required": false; "isSignal": true; }; "prevRole": { "alias": "prevRole"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[chatMessageControls]"], true, never>;
+}
+
+/**
+ * Default action buttons that appear under each assistant message:
+ * regenerate, copy-to-clipboard, thumbs up, thumbs down.
+ *
+ * Hidden by default, fades in on `:hover`/`:focus-within` of the parent
+ * `chat-message`, and stays visible on the current/last assistant message
+ * and on mobile.
+ */
+declare class ChatMessageActionsComponent {
+    /** Plain text content to copy. Required for the copy button to function. */
+    readonly content: _angular_core.InputSignal<string>;
+    /** When true, the regenerate button is disabled (e.g. while the agent is streaming). */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Emitted when the user clicks regenerate. Wire this to `agent.regenerate(index)`. */
+    readonly regenerate: _angular_core.OutputEmitterRef<void>;
+    /** Emitted with 'up' or 'down' when the user rates the response. */
+    readonly rate: _angular_core.OutputEmitterRef<"up" | "down">;
+    /** Emitted with the copied content after a successful clipboard write. */
+    readonly contentCopied: _angular_core.OutputEmitterRef<string>;
+    protected readonly copied: _angular_core.WritableSignal<boolean>;
+    protected readonly rating: _angular_core.WritableSignal<"up" | "down" | null>;
+    private readonly document;
+    protected onCopy(): Promise<void>;
+    protected onRate(value: 'up' | 'down'): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatMessageActionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatMessageActionsComponent, "chat-message-actions", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "regenerate": "regenerate"; "rate": "rate"; "contentCopied": "contentCopied"; }, never, never, true, never>;
+}
+
+declare class ChatWindowComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatWindowComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatWindowComponent, "chat-window", never, {}, {}, never, ["[chatHeader]", "[chatBody]", "[chatFooter]"], true, never>;
+}
+
+type TraceState = 'pending' | 'running' | 'done' | 'error';
+declare class ChatTraceComponent {
+    readonly state: _angular_core.InputSignal<TraceState>;
+    /** When state is not 'running' or 'error', honors this input as the default expansion. */
+    readonly defaultExpanded: _angular_core.InputSignal<boolean>;
+    /** null = follow auto state-driven logic; non-null = manual override (user click). */
+    private readonly _expandedOverride;
+    readonly expanded: _angular_core.Signal<boolean>;
+    readonly expandedStr: _angular_core.Signal<string>;
+    constructor();
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatTraceComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatTraceComponent, "chat-trace", never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; "defaultExpanded": { "alias": "defaultExpanded"; "required": false; "isSignal": true; }; }, {}, never, ["[traceIcon]", "[traceLabel]", "[traceMeta]", "*"], true, never>;
+}
+
+/**
+ * Renders an assistant's reasoning content as a compact pill that
+ * expands to reveal the underlying text. Three visual states:
+ *
+ * - Streaming: pill shows "Thinking…" with a pulsing dot; auto-expanded
+ *   so the user sees reasoning stream in real time.
+ * - Idle, with durationMs known: pill shows "Thought for {duration}";
+ *   collapsed by default, expand on click.
+ * - Idle, no duration: pill shows "Show reasoning"; collapsed by default.
+ *
+ * The body re-uses chat-streaming-md so reasoning content gets the same
+ * markdown rendering pipeline as the visible response (lists, code,
+ * step labels often appear in reasoning output).
+ *
+ * Internal state: a tristate "expanded" — null means follow auto state-
+ * driven logic (force-expand on isStreaming, otherwise honor
+ * defaultExpanded), boolean is a manual user choice that wins for the
+ * lifetime of the instance.
+ */
+declare class ChatReasoningComponent {
+    readonly content: _angular_core.InputSignal<string>;
+    readonly isStreaming: _angular_core.InputSignal<boolean>;
+    readonly durationMs: _angular_core.InputSignal<number | undefined>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly defaultExpanded: _angular_core.InputSignal<boolean>;
+    readonly hasContent: _angular_core.Signal<boolean>;
+    /** null = follow auto logic (streaming → expanded, else defaultExpanded). */
+    private readonly _expandedOverride;
+    readonly expanded: _angular_core.Signal<boolean>;
+    readonly expandedStr: _angular_core.Signal<string>;
+    readonly resolvedLabel: _angular_core.Signal<string>;
+    constructor();
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatReasoningComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatReasoningComponent, "chat-reasoning", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "isStreaming": { "alias": "isStreaming"; "required": false; "isSignal": true; }; "durationMs": { "alias": "durationMs"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "defaultExpanded": { "alias": "defaultExpanded"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ChatLauncherButtonComponent {
+    /** Fires when the inner <button> receives a click. Prefer this over
+     *  binding `(click)` on the host element — explicit output gives
+     *  consumers (and Playwright) an unambiguous click target that won't
+     *  be intercepted by sibling overlays in higher stacking contexts.
+     *  Native `(click)` on the host still works for back-compat: the
+     *  click event bubbles through unchanged. */
+    readonly clicked: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatLauncherButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatLauncherButtonComponent, "chat-launcher-button", never, {}, { "clicked": "clicked"; }, never, never, true, never>;
+}
+
+declare class ChatSuggestionsComponent {
+    readonly suggestions: _angular_core.InputSignal<string[]>;
+    readonly selected: _angular_core.OutputEmitterRef<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatSuggestionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatSuggestionsComponent, "chat-suggestions", never, { "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, never, true, never>;
+}
+
+/**
+ * Submits a trimmed message to the agent.
+ * Returns the trimmed string on success, or `null` if the input was empty.
+ */
+declare function submitMessage(agent: Agent, text: string): string | null;
+declare class ChatInputComponent {
+    readonly agent: _angular_core.InputSignal<Agent>;
+    readonly submitOnEnter: _angular_core.InputSignal<boolean>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** When true (default), shows a stop button while the agent is streaming. */
+    readonly showStopButton: _angular_core.InputSignal<boolean>;
+    readonly submitted: _angular_core.OutputEmitterRef<string>;
+    readonly stopped: _angular_core.OutputEmitterRef<void>;
+    readonly messageText: _angular_core.WritableSignal<string>;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    /** True while an IME composition (CJK input, accent, autocorrect) is active. */
+    protected readonly composing: _angular_core.WritableSignal<boolean>;
+    readonly focused: _angular_core.WritableSignal<boolean>;
+    /** Submit is allowed only when not loading and there's non-whitespace text. */
+    readonly canSubmit: _angular_core.Signal<boolean>;
+    /** The stop button only appears when the consumer opted in AND we're loading. */
+    readonly canStop: _angular_core.Signal<boolean>;
+    private readonly textareaEl;
+    /**
+     * Auto-resize the textarea to fit its content as the user types or pastes
+     * multi-line text. Caps at min(40vh, 320px); beyond that the textarea
+     * scrolls. Without this, multi-line input is hidden behind the rows="1"
+     * fixed height (caught by live browser smoke).
+     */
+    constructor();
+    focusTextarea(): void;
+    onSubmit(): void;
+    /** Abort the current streaming response (if the adapter supports it). */
+    onStop(): void;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatInputComponent, "chat-input", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; "submitOnEnter": { "alias": "submitOnEnter"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "showStopButton": { "alias": "showStopButton"; "required": false; "isSignal": true; }; }, { "submitted": "submitted"; "stopped": "stopped"; }, never, ["[chatInputBanner]", "[chatInputAttachments]", "[chatInputLeading]", "[chatInputModelSelect]", "[chatInputTrailing]", "[chatInputFooter]"], true, never>;
+}
+
+declare function isTyping(agent: Agent): boolean;
+declare class ChatTypingIndicatorComponent {
+    readonly agent: _angular_core.InputSignal<Agent>;
+    readonly visible: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatTypingIndicatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatTypingIndicatorComponent, "chat-typing-indicator", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ThreadMatch {
+    id: string;
+    title: string;
+    /** Optional secondary line, rendered muted under the title. */
+    subtitle?: string;
+}
+declare class ChatHistorySearchPaletteComponent {
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly query: _angular_core.ModelSignal<string>;
+    readonly results: _angular_core.InputSignal<ThreadMatch[]>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly threadSelected: _angular_core.OutputEmitterRef<string>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly listId: string;
+    private readonly inputEl;
+    constructor();
+    protected rowId(index: number): string;
+    protected activeRowId(): string | null;
+    protected onInput(e: Event): void;
+    protected onInputKeydown(e: KeyboardEvent): void;
+    protected onRowClick(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatHistorySearchPaletteComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatHistorySearchPaletteComponent, "chat-history-search-palette", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "query": { "alias": "query"; "required": false; "isSignal": true; }; "results": { "alias": "results"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "query": "queryChange"; "threadSelected": "threadSelected"; "closed": "closed"; }, never, never, true, never>;
+}
+
+interface OverflowMenuItem {
+    /** Stable id emitted via (itemSelected). */
+    id: string;
+    label: string;
+    /** 'destructive' renders the label in red. Default 'normal'. */
+    tone?: 'normal' | 'destructive';
+    /** Disabled items render muted and ignore clicks/keypresses. */
+    disabled?: boolean;
+}
+declare class ChatOverflowMenuComponent {
+    readonly open: _angular_core.InputSignal<boolean>;
+    readonly items: _angular_core.InputSignal<OverflowMenuItem[]>;
+    /** Element the menu anchors against (positions just below its bottom-right corner). */
+    readonly anchor: _angular_core.InputSignal<HTMLElement | null>;
+    /** Alternative anchor: explicit viewport coordinates (e.g. cursor position
+     *  from a right-click). Takes precedence over `anchor` when set. */
+    readonly anchorPos: _angular_core.InputSignal<{
+        x: number;
+        y: number;
+    } | null>;
+    readonly itemSelected: _angular_core.OutputEmitterRef<string>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    protected readonly position: _angular_core.Signal<{
+        top: number;
+        left: number;
+    }>;
+    constructor();
+    protected onItemClick(item: OverflowMenuItem): void;
+    protected onMenuKeydown(e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatOverflowMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatOverflowMenuComponent, "chat-overflow-menu", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "anchorPos": { "alias": "anchorPos"; "required": false; "isSignal": true; }; }, { "itemSelected": "itemSelected"; "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class ChatConfirmDialogComponent {
+    readonly open: _angular_core.InputSignal<boolean>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly body: _angular_core.InputSignal<string>;
+    readonly confirmLabel: _angular_core.InputSignal<string>;
+    readonly cancelLabel: _angular_core.InputSignal<string>;
+    readonly tone: _angular_core.InputSignal<"normal" | "destructive">;
+    readonly confirmed: _angular_core.OutputEmitterRef<void>;
+    readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    private readonly instanceId;
+    protected readonly titleId: string;
+    protected readonly bodyId: string;
+    private readonly cancelBtn;
+    constructor();
+    protected onDialogKeydown(e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatConfirmDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatConfirmDialogComponent, "chat-confirm-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "body": { "alias": "body"; "required": false; "isSignal": true; }; "confirmLabel": { "alias": "confirmLabel"; "required": false; "isSignal": true; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; }, { "confirmed": "confirmed"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+type ChatScrollBubbleMode = 'streaming' | 'idle';
+declare class ChatScrollBubbleComponent {
+    readonly mode: _angular_core.InputSignal<ChatScrollBubbleMode>;
+    readonly clicked: _angular_core.OutputEmitterRef<void>;
+    protected readonly ariaLabel: _angular_core.Signal<"Latest activity" | "Scroll to latest">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatScrollBubbleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatScrollBubbleComponent, "chat-scroll-bubble", never, { "mode": { "alias": "mode"; "required": true; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
+}
+
+declare function extractErrorMessage(error: unknown): string | null;
+declare class ChatErrorComponent {
+    readonly agent: _angular_core.InputSignal<Agent>;
+    readonly errorMessage: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatErrorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatErrorComponent, "chat-error", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare function getInterrupt(agent: Agent): AgentInterrupt | undefined;
+declare class ChatInterruptComponent {
+    readonly agent: _angular_core.InputSignal<Agent>;
+    readonly templateRef: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly interrupt: _angular_core.Signal<AgentInterrupt | undefined>;
+    defaultText(i: AgentInterrupt): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatInterruptComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatInterruptComponent, "chat-interrupt", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; }, {}, ["templateRef"], never, true, never>;
+}
+
+interface ToolCallInfo {
+    id: string;
+    name: string;
+    args: unknown;
+    result?: unknown;
+    /** Optional — present when the parent provides it. Drives the pill + default-collapsed logic. */
+    status?: ToolCallStatus;
+}
+declare class ChatToolCallCardComponent {
+    readonly toolCall: _angular_core.InputSignal<ToolCallInfo>;
+    readonly defaultCollapsed: _angular_core.InputSignal<boolean>;
+    readonly status: _angular_core.Signal<ToolCallStatus>;
+    readonly state: _angular_core.Signal<TraceState>;
+    readonly autoExpanded: _angular_core.Signal<boolean>;
+    readonly ariaLabel: _angular_core.Signal<string>;
+    formatJson(value: unknown): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatToolCallCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatToolCallCardComponent, "chat-tool-call-card", never, { "toolCall": { "alias": "toolCall"; "required": true; "isSignal": true; }; "defaultCollapsed": { "alias": "defaultCollapsed"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Template-context surface available to a per-tool template. The first
+ * argument is the ToolCall itself (let-call); status is exposed as a
+ * named context property (let-status="status").
+ */
+interface ChatToolCallTemplateContext {
+    $implicit: ToolCall;
+    status: ToolCallStatus;
+}
+/**
+ * Registers a per-tool-name template inside <chat-tool-calls>. The
+ * primitive collects all directive instances via contentChildren() and
+ * dispatches incoming calls by their `name` field. A literal "*" name
+ * registers a wildcard catch-all that handles any tool name without a
+ * specific template registered.
+ *
+ * Usage:
+ *
+ *   <chat-tool-calls [agent]="agent" [message]="msg">
+ *     <ng-template chatToolCallTemplate="search_web" let-call let-status="status">
+ *       <my-search-result-card [query]="call.args.query" [status]="status"/>
+ *     </ng-template>
+ *     <ng-template chatToolCallTemplate="*" let-call>
+ *       <chat-tool-call-card [toolCall]="call"/>
+ *     </ng-template>
+ *   </chat-tool-calls>
+ */
+declare class ChatToolCallTemplateDirective {
+    /** The tool name this template handles, or "*" for the wildcard catch-all. */
+    readonly name: _angular_core.InputSignal<string>;
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatToolCallTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ChatToolCallTemplateDirective, "[chatToolCallTemplate]", never, { "name": { "alias": "chatToolCallTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface Group {
+    name: string;
+    calls: ToolCall[];
+    templateRef?: ChatToolCallTemplateDirective;
+}
+declare class ChatToolCallsComponent {
+    readonly agent: _angular_core.InputSignal<Agent>;
+    readonly message: _angular_core.InputSignal<Message | undefined>;
+    readonly grouping: _angular_core.InputSignal<"auto" | "none">;
+    readonly groupSummary: _angular_core.InputSignal<((name: string, count: number) => string) | undefined>;
+    /**
+     * Tool names whose groups should be hidden. Used by chat compositions
+     * to filter out internal/orchestration tools (e.g. GenUI dispatchers)
+     * whose args streaming is not meaningful to surface in the chat.
+     * Default empty — preserves prior behavior for non-filtering consumers.
+     */
+    readonly excludeToolNames: _angular_core.InputSignal<readonly string[]>;
+    /** Per-tool-name + wildcard templates registered as content children. */
+    readonly templates: _angular_core.Signal<readonly ChatToolCallTemplateDirective[]>;
+    private readonly templateRegistry;
+    readonly toolCalls: _angular_core.Signal<ToolCall[]>;
+    readonly groups: _angular_core.Signal<Group[]>;
+    private readonly _expandedGroups;
+    readonly expandedGroups: _angular_core.Signal<Set<number>>;
+    toggleGroup(index: number): void;
+    protected summarize(name: string, count: number): string;
+    protected toToolCallInfo(tc: ToolCall): ToolCallInfo;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatToolCallsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatToolCallsComponent, "chat-tool-calls", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "grouping": { "alias": "grouping"; "required": false; "isSignal": true; }; "groupSummary": { "alias": "groupSummary"; "required": false; "isSignal": true; }; "excludeToolNames": { "alias": "excludeToolNames"; "required": false; "isSignal": true; }; }, {}, ["templates"], never, true, never>;
+}
+
+declare class ChatSubagentsComponent {
+    readonly agent: _angular_core.InputSignal<Agent>;
+    readonly templateRef: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly activeSubagents: _angular_core.Signal<Subagent[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatSubagentsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatSubagentsComponent, "chat-subagents", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; }, {}, ["templateRef"], never, true, never>;
+}
+
+type Project = {
+    id: string;
+    name: string;
+    /** Open shape — consumers may add icon, color, createdAt, etc. */
+    [key: string]: unknown;
+};
+/**
+ * Consumer-provided adapter for project lifecycle actions. The framework calls
+ * these methods after user confirmation (delete) or commit (create/rename) and
+ * manages optimistic UI + rollback on rejection.
+ */
+interface ProjectActionAdapter {
+    /** Create a new project. Returns the new project id; consumer is expected
+     *  to also refresh its projects signal. */
+    create?(name: string): Promise<{
+        id: string;
+    }>;
+    rename?(projectId: string, newName: string): Promise<void>;
+    /** Permanently delete the project. The framework calls this AFTER user
+     *  confirms via the confirm dialog. */
+    delete?(projectId: string): Promise<void>;
+}
+declare class ChatProjectListComponent {
+    readonly projects: _angular_core.InputSignal<Project[]>;
+    readonly activeProjectId: _angular_core.InputSignal<string | null>;
+    readonly showNewProjectButton: _angular_core.InputSignal<boolean>;
+    readonly actions: _angular_core.InputSignal<ProjectActionAdapter | null>;
+    readonly projectSelected: _angular_core.OutputEmitterRef<string>;
+    readonly newProjectRequested: _angular_core.OutputEmitterRef<void>;
+    protected readonly creatingProject: _angular_core.WritableSignal<boolean>;
+    protected readonly creatingValue: _angular_core.WritableSignal<string>;
+    protected readonly editingProjectId: _angular_core.WritableSignal<string | null>;
+    protected readonly editingValue: _angular_core.WritableSignal<string>;
+    protected readonly menuOpenForId: _angular_core.WritableSignal<string | null>;
+    protected readonly menuAnchor: _angular_core.WritableSignal<HTMLElement | null>;
+    protected readonly confirmDeleteId: _angular_core.WritableSignal<string | null>;
+    private readonly pendingHidden;
+    private readonly pendingRenames;
+    protected readonly visibleProjects: _angular_core.Signal<Project[]>;
+    protected readonly currentMenuItems: _angular_core.Signal<OverflowMenuItem[]>;
+    private readonly createInput;
+    private readonly editInput;
+    constructor();
+    protected selectProject(projectId: string): void;
+    protected showKebab(): boolean;
+    protected openMenu(projectId: string, anchor: HTMLElement): void;
+    protected onMenuAction(id: string): void;
+    protected onNewProjectClicked(): void;
+    protected onCreateInput(e: Event): void;
+    protected cancelCreate(): void;
+    protected commitCreate(): Promise<void>;
+    protected onEditInput(e: Event): void;
+    protected cancelRename(): void;
+    protected commitRename(projectId: string): Promise<void>;
+    protected performDelete(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatProjectListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatProjectListComponent, "chat-project-list", never, { "projects": { "alias": "projects"; "required": true; "isSignal": true; }; "activeProjectId": { "alias": "activeProjectId"; "required": false; "isSignal": true; }; "showNewProjectButton": { "alias": "showNewProjectButton"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; }, { "projectSelected": "projectSelected"; "newProjectRequested": "newProjectRequested"; }, never, never, true, never>;
+}
+
+type Thread = {
+    id: string;
+    /** Optional human-friendly label. Falls back to a slice of the id. */
+    title?: string;
+    /** Optional epoch-ms timestamp used by the default item template to
+     *  render a relative-time line ("just now" / "5 min ago"). When absent
+     *  the default template omits the second line. */
+    updatedAt?: number;
+    /** Optional lifecycle status. Undefined treated as 'active'. The framework
+     *  does NOT auto-filter by this field — consumers pre-filter into separate
+     *  `threads` and `archivedThreads` inputs on chat-sidenav. The field is
+     *  typed documentation of intent. */
+    status?: 'active' | 'archived';
+    /** Optional flag indicating the thread is pinned (sticky-top). The framework
+     *  renders a pin icon when true but does NOT sort — the consumer pre-sorts
+     *  pinned threads to the top of the `threads` input. */
+    pinned?: boolean;
+    /** Optional project association. Consumers pre-filter threads by project
+     *  before passing to the sidenav. Null/undefined means no project. */
+    projectId?: string | null;
+    [key: string]: unknown;
+};
+/**
+ * Per-thread row-action adapter. Consumer-provided. The framework calls
+ * these methods after user confirmation (delete) or commit (rename) and
+ * manages optimistic UI + rollback on rejection.
+ *
+ * Consumers MUST refresh their `threads` signal on success — the framework
+ * clears optimistic overrides in a `finally` block, so a successful adapter
+ * call that leaves the input list unchanged would re-render the row.
+ */
+interface ThreadActionAdapter {
+    delete?(threadId: string): Promise<void>;
+    rename?(threadId: string, newTitle: string): Promise<void>;
+    /** Archive a thread (reversible). No confirmation dialog — framework calls
+     *  this immediately on click. */
+    archive?(threadId: string): Promise<void>;
+    /** Restore an archived thread to the active list. */
+    unarchive?(threadId: string): Promise<void>;
+    /** Mark the thread as pinned. */
+    pin?(threadId: string): Promise<void>;
+    /** Unpin a previously pinned thread. */
+    unpin?(threadId: string): Promise<void>;
+    /** Move thread to a project (or pass null to remove from any project).
+     *  Optimistically hides the row from the current project's visible list;
+     *  consumer is expected to refresh the threads input. */
+    moveToProject?(threadId: string, projectId: string | null): Promise<void>;
+    /** Reorder a pinned thread. `beforeId` is the id of the pinned thread it
+     *  should be placed before, or null to move to the end of the pinned list.
+     *  Framework optimistically reorders the visible list and awaits this
+     *  method; rejection rolls back. */
+    reorderPinned?(threadId: string, beforeId: string | null): Promise<void>;
+}
+declare class ChatThreadListComponent {
+    readonly threads: _angular_core.InputSignal<Thread[]>;
+    readonly activeThreadId: _angular_core.InputSignal<string>;
+    readonly showNewThreadButton: _angular_core.InputSignal<boolean>;
+    readonly actions: _angular_core.InputSignal<ThreadActionAdapter | null>;
+    readonly mode: _angular_core.InputSignal<"active" | "archived">;
+    readonly projects: _angular_core.InputSignal<Project[] | null>;
+    readonly threadSelected: _angular_core.OutputEmitterRef<string>;
+    readonly newThreadRequested: _angular_core.OutputEmitterRef<void>;
+    readonly templateRef: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected readonly editingThreadId: _angular_core.WritableSignal<string | null>;
+    protected readonly editingValue: _angular_core.WritableSignal<string>;
+    protected readonly menuOpenForId: _angular_core.WritableSignal<string | null>;
+    protected readonly menuAnchor: _angular_core.WritableSignal<HTMLElement | null>;
+    /** Cursor-anchored position when the menu was opened via right-click.
+     *  Mutually exclusive with `menuAnchor` — set one, null the other. */
+    protected readonly menuAnchorPos: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+    } | null>;
+    protected readonly confirmDeleteId: _angular_core.WritableSignal<string | null>;
+    protected readonly moveMenuOpenForId: _angular_core.WritableSignal<string | null>;
+    protected readonly moveMenuItems: _angular_core.Signal<OverflowMenuItem[]>;
+    /** Ids hidden from the rendered list during pending delete, archive, or
+     *  unarchive. The framework doesn't distinguish — all three actions hide
+     *  the row from the current list until the adapter promise settles. */
+    private readonly pendingHidden;
+    private readonly pendingRenames;
+    /** Pending reorder overrides for pinned threads. Each entry: "move this id
+     *  to before that id (or to end if null)". Cleared in `finally` after the
+     *  adapter call settles. */
+    private readonly pendingOrder;
+    /** Id of the thread currently being dragged via HTML5 drag-and-drop. */
+    protected readonly draggingThreadId: _angular_core.WritableSignal<string | null>;
+    /** Drop target during a drag: which row, and whether the indicator shows
+     *  on the top edge ('before') or bottom edge ('after'). */
+    protected readonly dropTarget: _angular_core.WritableSignal<{
+        threadId: string;
+        position: "before" | "after";
+    } | null>;
+    protected readonly visibleThreads: _angular_core.Signal<Thread[]>;
+    protected readonly currentMenuItems: _angular_core.Signal<OverflowMenuItem[]>;
+    private readonly editInput;
+    selectThread(threadId: string): void;
+    protected threadLabel(thread: Thread): string;
+    protected relativeTime(epochMs: number): string;
+    protected showKebab(): boolean;
+    protected openMenu(threadId: string, anchor: HTMLElement): void;
+    /** Right-click on a row opens the same overflow menu anchored at the
+     *  cursor. Always prevents the native context menu — including when the
+     *  adapter exposes no row actions (in which case we open nothing rather
+     *  than confusing the user with the OS menu on what looks like a custom
+     *  list). */
+    protected onRowContextMenu(threadId: string, event: MouseEvent): void;
+    /** First grapheme of a title rendered as an uppercase initial for the
+     *  collapsed sidenav. Falls back to "?" for empty/whitespace titles. */
+    protected initialOf(title: string): string;
+    protected onMenuAction(id: string): void;
+    protected performPin(threadId: string): Promise<void>;
+    protected performUnpin(threadId: string): Promise<void>;
+    protected onEditInput(e: Event): void;
+    protected cancelRename(): void;
+    protected commitRename(threadId: string): Promise<void>;
+    protected performDelete(): Promise<void>;
+    protected performArchive(threadId: string): Promise<void>;
+    protected onMoveMenuAction(itemId: string): void;
+    protected performMoveToProject(threadId: string, projectId: string | null): Promise<void>;
+    protected performReorderPinned(threadId: string, beforeId: string | null): Promise<void>;
+    protected performMoveUp(threadId: string): Promise<void>;
+    protected performMoveDown(threadId: string): Promise<void>;
+    protected onDragStart(e: DragEvent, threadId: string): void;
+    protected onDragOver(e: DragEvent, threadId: string): void;
+    protected onDragLeave(_e: DragEvent, threadId: string): void;
+    protected onDrop(e: DragEvent, targetThreadId: string): void;
+    protected onDragEnd(): void;
+    protected dropPositionFor(threadId: string): 'before' | 'after' | null;
+    protected performUnarchive(threadId: string): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatThreadListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatThreadListComponent, "chat-thread-list", never, { "threads": { "alias": "threads"; "required": true; "isSignal": true; }; "activeThreadId": { "alias": "activeThreadId"; "required": false; "isSignal": true; }; "showNewThreadButton": { "alias": "showNewThreadButton"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "projects": { "alias": "projects"; "required": false; "isSignal": true; }; }, { "threadSelected": "threadSelected"; "newThreadRequested": "newThreadRequested"; }, ["templateRef"], never, true, never>;
+}
+
+declare class ChatGenuiSkeletonComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatGenuiSkeletonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatGenuiSkeletonComponent, "chat-genui-skeleton", never, {}, {}, never, never, true, never>;
+}
+
+declare class ChatTimelineComponent {
+    readonly agent: _angular_core.InputSignal<AgentWithHistory>;
+    readonly checkpointSelected: _angular_core.OutputEmitterRef<AgentCheckpoint>;
+    readonly templateRef: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly history: _angular_core.Signal<AgentCheckpoint[]>;
+    selectCheckpoint(cp: AgentCheckpoint): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatTimelineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatTimelineComponent, "chat-timeline", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; }, { "checkpointSelected": "checkpointSelected"; }, ["templateRef"], never, true, never>;
+}
+
+declare class ChatGenerativeUiComponent {
+    readonly spec: _angular_core.InputSignal<Spec | null>;
+    readonly registry: _angular_core.InputSignal<AngularRegistry | undefined>;
+    readonly store: _angular_core.InputSignal<StateStore | undefined>;
+    readonly handlers: _angular_core.InputSignal<Record<string, (params: Record<string, unknown>) => unknown | Promise<unknown>> | undefined>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly events: _angular_core.OutputEmitterRef<RenderEvent>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatGenerativeUiComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatGenerativeUiComponent, "chat-generative-ui", never, { "spec": { "alias": "spec"; "required": false; "isSignal": true; }; "registry": { "alias": "registry"; "required": false; "isSignal": true; }; "store": { "alias": "store"; "required": false; "isSignal": true; }; "handlers": { "alias": "handlers"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "events": "events"; }, never, never, true, never>;
+}
+
+/**
+ * Empty-state owner. Renders a centered greeting + slot-projected input +
+ * optional vertical suggestion rows. Mounted only when the parent chat has
+ * no messages and welcome is not disabled.
+ *
+ * Slots:
+ *   [chatWelcomeTitle]       — replaces the default <h1> "How can I help?"
+ *   [chatWelcomeInput]       — projects the chat input into the center column
+ *   [chatWelcomeSuggestions] — projects suggestion rows below the input
+ *
+ * Host CSS variables (override on :host or any ancestor):
+ *   --ngaf-chat-welcome-max-width  default 36rem
+ *   --ngaf-chat-welcome-gap        default 1.25rem
+ *   --ngaf-chat-welcome-padding    default 24px
+ */
+declare class ChatWelcomeComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatWelcomeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatWelcomeComponent, "chat-welcome", never, {}, {}, never, ["[chatWelcomeTitle]", "[chatWelcomeInput]", "[chatWelcomeSuggestions]"], true, never>;
+}
+
+declare class ChatWelcomeSuggestionComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly selected: _angular_core.OutputEmitterRef<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatWelcomeSuggestionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatWelcomeSuggestionComponent, "chat-welcome-suggestion", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; }, { "selected": "selected"; }, never, ["[chatWelcomeSuggestionIcon]"], true, never>;
+}
+
+interface ChatSelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+/**
+ * Generic single-select dropdown. Designed to slot into the chat input pill
+ * (via [chatInputModelSelect]) but usable anywhere.
+ *
+ * Inputs:
+ *   options      — array of { value, label, disabled? }; required
+ *   value        — currently selected value (two-way via model())
+ *   placeholder  — trigger label when no option matches; default 'Select'
+ *   disabled     — disables the trigger; default false
+ *   menuLabel    — aria-label for the popover; defaults to placeholder
+ */
+declare class ChatSelectComponent {
+    readonly options: _angular_core.InputSignal<readonly ChatSelectOption[]>;
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly menuLabel: _angular_core.InputSignal<string | undefined>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly currentLabel: _angular_core.Signal<string>;
+    private readonly hostEl;
+    private readonly document;
+    private readonly destroyRef;
+    constructor();
+    protected toggle(): void;
+    protected selectOption(opt: ChatSelectOption): void;
+    protected onTriggerKeydown(e: KeyboardEvent): void;
+    protected onMenuKeydown(e: KeyboardEvent): void;
+    private focusOption;
+    private focusTrigger;
+    private moveFocus;
+    private queryOptions;
+    private queryTrigger;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatSelectComponent, "chat-select", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "menuLabel": { "alias": "menuLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * ContentChild template directive for custom citation card rendering.
+ * Usage: <ng-template chatCitationCard let-citation>...</ng-template>
+ */
+declare class ChatCitationCardTemplateDirective {
+    readonly tpl: TemplateRef<{
+        $implicit: Citation;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatCitationCardTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ChatCitationCardTemplateDirective, "ng-template[chatCitationCard]", never, {}, {}, never, never, true, never>;
+}
+declare class ChatCitationsComponent {
+    readonly message: _angular_core.InputSignal<Message>;
+    readonly heading: _angular_core.InputSignal<string>;
+    cardTpl: ChatCitationCardTemplateDirective | null;
+    /**
+     * Optional resolver — present when chat-citations is rendered inside a
+     * chat-message that provides CitationsResolverService (the standard
+     * placement). When absent, the panel reads only Message.citations.
+     */
+    private readonly resolver;
+    /**
+     * Combined citation list:
+     *   1. Message.citations (provider-populated, takes precedence by id)
+     *   2. Markdown sidecar defs (Pandoc-formatted [^id]: lines), merged in
+     *      for any id not already present.
+     *
+     * Sorted by index ascending. This guarantees the sources panel surfaces
+     * citations whether they come from message metadata, content syntax, or
+     * both — matching the same precedence as inline-marker resolution.
+     */
+    protected readonly citations: _angular_core.Signal<Citation[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatCitationsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatCitationsComponent, "chat-citations", never, { "message": { "alias": "message"; "required": true; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; }, {}, ["cardTpl"], never, true, never>;
+}
+
+declare class ChatCitationsCardComponent {
+    readonly citation: _angular_core.InputSignal<Citation>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatCitationsCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatCitationsCardComponent, "chat-citations-card", never, { "citation": { "alias": "citation"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ChatLifecycle {
+    /** True after `<chat>` initializes with a non-null agent binding. */
+    readonly componentReady: Signal<boolean>;
+    /** True after the first user submit. Sticky for the life of the chat instance — does NOT reset on clearThread. */
+    readonly firstMessageSent: Signal<boolean>;
+    /** Count of user submits. Resets on clearThread. */
+    readonly messageCount: Signal<number>;
+    /** Epoch ms of the most recent user submit. Resets on clearThread. */
+    readonly inputSubmittedAt: Signal<number | null>;
+}
+declare const CHAT_LIFECYCLE: InjectionToken<ChatLifecycle>;
+
+interface ElementAccumulationState {
+    hasType: boolean;
+    hasProps: boolean;
+    hasChildren: boolean;
+    streaming: boolean;
+}
+interface ParseTreeStore {
+    push(chunk: string): void;
+    readonly spec: Signal<Spec | null>;
+    readonly elementStates: Signal<Map<string, ElementAccumulationState>>;
+}
+declare function createParseTreeStore(parser: PartialJsonParser): ParseTreeStore;
+
+/** Chat-internal projection of an A2UI component, materialized by the
+ * surface store. Distinct from the wire-format `A2uiComponent` in
+ * `@threadplane/a2ui` (which carries the raw `component: A2uiComponentDef`
+ * payload) — this type adds the per-component readiness fields the
+ * progressive renderer consumes. */
+interface A2uiComponentView {
+    /** The component's id (same as the wire-format `A2uiComponent.id`). */
+    readonly id: string;
+    /** The component type key — e.g. `'Button'`, `'TextField'` — matched
+     * against catalog `views` entries. */
+    readonly type: string;
+    /** Data model paths this component references via its `{$.path}` prop
+     * expressions. Extracted once on `surfaceUpdate` apply; immutable. */
+    readonly bindings: readonly string[];
+    /** Monotonic: `false` until every binding has resolved at least once
+     * in the accumulated data model, then `true` forever. Once `true`,
+     * subsequent `dataModelUpdate` envelopes push new prop values but do
+     * NOT flip this back to `false`. */
+    readonly ready: boolean;
+    /** Resolved property bag. Meaningful only when `ready === true`. */
+    readonly props: Readonly<Record<string, unknown>>;
+    /** The raw wire-format component def, retained so the slot directive
+     * can look up the catalog entry by type and resolve nested children
+     * on re-renders. */
+    readonly def: A2uiComponentDef;
+}
+
+/** Chat-side state for a surface — wraps the wire-format `A2uiSurface`
+ * with the per-component projection the progressive renderer consumes.
+ * Both maps are kept in sync; the wire shape preserves existing
+ * `surfaceToSpec` semantics, the view shape carries readiness. */
+interface A2uiSurfaceState {
+    readonly surface: A2uiSurface;
+    readonly componentViews: ReadonlyMap<string, A2uiComponentView>;
+}
+interface A2uiSurfaceStore {
+    apply(message: A2uiMessage): void;
+    /**
+     * Live-stream entry point. Iterates envelopes and feeds each through
+     * `apply()`. Records the tool_call_id so the wrapped-content classifier
+     * can short-circuit duplicate dispatch when the final AIMessage arrives.
+     */
+    applyPartialArgs(toolCallId: string, envelopes: readonly A2uiMessage[]): void;
+    /** True if a tool_call_id has produced live envelopes via applyPartialArgs. */
+    isPartialLive(toolCallId: string): boolean;
+    /** Wire-format surfaces, for downstream consumers (e.g. surfaceToSpec). */
+    readonly surfaces: Signal<Map<string, A2uiSurface>>;
+    surface(surfaceId: string): Signal<A2uiSurface | undefined>;
+    /** Chat-side projections with per-component readiness. */
+    readonly surfaceStates: Signal<Map<string, A2uiSurfaceState>>;
+    surfaceState(surfaceId: string): Signal<A2uiSurfaceState | undefined>;
+}
+declare function createA2uiSurfaceStore(): A2uiSurfaceStore;
+
+type ContentType = 'pending' | 'markdown' | 'json-render' | 'a2ui' | 'mixed';
+interface ContentClassifier {
+    update(content: string): void;
+    readonly type: Signal<ContentType>;
+    readonly markdown: Signal<string>;
+    readonly spec: Signal<Spec | null>;
+    readonly elementStates: Signal<Map<string, ElementAccumulationState>>;
+    readonly a2uiSurfaces: Signal<Map<string, A2uiSurface>>;
+    readonly a2uiSurfaceStates: Signal<Map<string, A2uiSurfaceState>>;
+    readonly streaming: Signal<boolean>;
+    readonly errors: Signal<string[]>;
+    dispose(): void;
+}
+declare function createContentClassifier(): ContentClassifier;
+
+/**
+ * Extracts a human-readable string from a message's content.
+ *
+ * `BaseMessage.content` is `string | MessageContentComplex[]`. Reasoning-
+ * capable models (OpenAI gpt-5/o-series, Anthropic) emit complex arrays of
+ * typed blocks: `{type:'text',text}`, `{type:'reasoning',...}`, tool-use
+ * blocks, etc. We render only the visible text portions and skip anything
+ * else. Stringifying the whole array would dump raw JSON like
+ * `[{"type":"text",...}]` into the chat bubble.
+ */
+declare function messageContent(message: BaseMessage): string;
+
+interface ChatRenderEvent {
+    readonly messageIndex: number;
+    readonly surfaceId?: string;
+    readonly event: RenderEvent;
+}
+
+declare class ChatComponent {
+    readonly agent: _angular_core.InputSignal<Agent>;
+    readonly views: _angular_core.InputSignal<Readonly<Record<string, _angular_core.Type<unknown> | _threadplane_render.RenderViewEntry>> | undefined>;
+    readonly store: _angular_core.InputSignal<StateStore | undefined>;
+    readonly handlers: _angular_core.InputSignal<Record<string, (params: Record<string, unknown>) => unknown | Promise<unknown>>>;
+    readonly threads: _angular_core.InputSignal<Thread[]>;
+    readonly activeThreadId: _angular_core.InputSignal<string>;
+    readonly welcomeDisabled: _angular_core.InputSignal<boolean>;
+    /**
+     * High-level model-picker API. When `modelOptions` is non-empty, the chat
+     * composition renders a `<chat-select>` inside the input pill (in BOTH
+     * welcome and conversation modes), wired to the two-way `selectedModel`
+     * model. Consumers who want full control should leave `modelOptions`
+     * empty and project a `<chat-select chatInputModelSelect>` themselves.
+     */
+    readonly modelOptions: _angular_core.InputSignal<readonly ChatSelectOption[]>;
+    /**
+     * When `false`, hide the auto-rendered model picker even when
+     * `modelOptions` is non-empty. Useful in cramped surfaces (popup,
+     * sidebar) where the picker crowds the input. Defaults to `true`.
+     * Has no effect when consumers project their own
+     * `<chat-select chatInputModelSelect>` via content projection.
+     */
+    readonly showModelPicker: _angular_core.InputSignal<boolean>;
+    readonly selectedModel: _angular_core.ModelSignal<string>;
+    readonly modelPickerPlaceholder: _angular_core.InputSignal<string>;
+    /**
+     * Tool names whose calls produce a rendered GenUI surface rather than
+     * visible text. Used to (a) filter <chat-tool-calls> so internal
+     * dispatchers don't render args JSON as cards, and (b) detect
+     * "this is a GenUI turn" for the building-UI skeleton.
+     * Default covers the canonical A2UI + json-render schema tools.
+     */
+    readonly genuiToolNames: _angular_core.InputSignal<readonly string[]>;
+    readonly showWelcome: _angular_core.Signal<boolean>;
+    readonly threadSelected: _angular_core.OutputEmitterRef<string>;
+    readonly renderEvent: _angular_core.OutputEmitterRef<ChatRenderEvent>;
+    /** Emitted when the user clicks the regenerate button on an assistant message. */
+    readonly regenerate: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when the user rates an assistant message. */
+    readonly rate: _angular_core.OutputEmitterRef<{
+        messageIndex: number;
+        rating: "up" | "down";
+    }>;
+    /** Emitted when the user copies an assistant message. */
+    readonly messageCopy: _angular_core.OutputEmitterRef<{
+        messageIndex: number;
+        content: string;
+    }>;
+    private readonly _internalStore;
+    readonly resolvedStore: _angular_core.Signal<StateStore | undefined>;
+    readonly renderRegistry: _angular_core.Signal<_threadplane_render.AngularRegistry | undefined>;
+    readonly messageContent: typeof messageContent;
+    /**
+     * Renderable content for a human-role message bubble. Most human
+     * messages are typed prompts and pass through `messageContent`
+     * unchanged. A2UI action messages (e.g. form submits, button clicks
+     * on a rendered surface) flow through the same submit channel and
+     * land in the message stream as a HumanMessage whose content is a
+     * JSON-serialized `A2uiActionMessage`. Showing the raw JSON as if
+     * the user typed it leaks the protocol; per the A2UI v0.9 spec
+     * those events resemble tool calls more than user utterances.
+     *
+     * `a2uiActionLabel` returns a short human-readable label for
+     * recognized action shapes ("Search flights", "Selected flight UA123",
+     * etc.) — or null for any non-action content, in which case we fall
+     * back to the original text.
+     */
+    protected humanContent(message: unknown): string;
+    /**
+     * True while a message's reasoning is mid-stream — i.e. it's the latest
+     * message, the agent is loading, the message has reasoning content, and
+     * no response text has arrived yet. Once the response text begins, the
+     * reasoning pill collapses (per its internal logic).
+     */
+    protected isReasoningStreaming(message: Message, index: number): boolean;
+    private readonly classifiers;
+    private readonly destroyRef;
+    private readonly lifecycle;
+    private eventsSubscribed;
+    /**
+     * Shared A2UI surface store fed by the live partial-args bridge. The
+     * content-classifier path will share this store via tool_call_id
+     * short-circuit (skipping re-dispatch for live tool_call_ids).
+     */
+    protected readonly liveSurfaceStore: A2uiSurfaceStore;
+    private readonly partialBridge;
+    private partialEventsLastIndex;
+    private readonly scrollContainer;
+    private readonly messageCount;
+    private prevMessageCount;
+    private wasLoading;
+    protected readonly pinned: _angular_core.WritableSignal<boolean>;
+    private programmaticScrollCount;
+    private static readonly PIN_TOLERANCE_PX;
+    /**
+     * True iff there's a current (last-index) assistant message that's
+     * still streaming. The bubble's own caret already signals loading;
+     * we suppress the floor typing-indicator in that case so the user
+     * doesn't see two loading affordances at once.
+     *
+     * Matches the same `streaming + current` condition the bubble uses
+     * to enable `.chat-message__caret`:
+     *   `agent().isLoading() && i === agent().messages().length - 1`
+     *   `i === agent().messages().length - 1`
+     *
+     * Restricted to assistant role because the caret only renders on
+     * assistant bubbles (`:host([data-role="assistant"][data-current=...
+     *  ][data-streaming=...])`).
+     */
+    protected readonly currentAssistantStreaming: _angular_core.Signal<boolean>;
+    constructor();
+    prevRole(index: number): ChatMessageRole | undefined;
+    protected onScroll(): void;
+    protected onScrollBubbleClick(): void;
+    protected onUserSubmitted(): void;
+    /**
+     * Programmatic submit. Calls `agent.submit({ message: text })` and updates
+     * the CHAT_LIFECYCLE signals. Trimmed-empty text is a no-op.
+     */
+    submitMessage(text: string): void;
+    /**
+     * Clears local view state (classifiers, surface store, lifecycle counters)
+     * for a new thread.
+     *
+     * Resets messageCount to 0 and inputSubmittedAt to null. componentReady and
+     * firstMessageSent are NOT reset (sticky for the chat instance lifetime).
+     */
+    clearThread(): void;
+    private recordSubmit;
+    /**
+     * Look up the previous message in the agent's messages list.
+     * Returns undefined for the first message.
+     */
+    protected prevMessage(index: number): unknown;
+    /**
+     * True when this assistant message is part of a GenUI render turn.
+     * Walks backward through messages from `index` until it finds either
+     * an assistant message with `tool_calls` referencing a GenUI tool
+     * (→ this turn produces a surface) or a human message (→ the
+     * preceding turn ended; this assistant message stands on its own).
+     *
+     * Also checks the message itself for:
+     *   - `extra.tool_calls[].name` matching a GenUI tool (post-streaming
+     *     state of the tool-call AI message), OR
+     *   - `extra.content[].type === 'function_call' && .name` matching
+     *     (live during the OpenAI Responses-API streaming chunks before
+     *     `tool_calls` populates).
+     *
+     * The walk-back approach is robust to LangGraph's in-place
+     * replacement of the ToolMessage (which strips the `name` field),
+     * unlike a single prev-message check.
+     */
+    protected isGenuiTurn(message: unknown, _prevMsg: unknown, index?: number): boolean;
+    classifyMessage(content: string, message: {
+        id?: string;
+    }): ContentClassifier;
+    clearClassifiers(): void;
+    onSpecEvent(event: RenderEvent, messageIndex: number): void;
+    onA2uiAction(message: A2uiActionMessage): void;
+    onA2uiEvent(event: RenderEvent, messageIndex: number, surfaceId: string): void;
+    /** Regenerate the assistant response at the given message index. */
+    onRegenerate(messageIndex: number): void;
+    onRate(message: unknown, value: 'up' | 'down'): void;
+    onCopy(message: unknown, content: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatComponent, "chat", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; "views": { "alias": "views"; "required": false; "isSignal": true; }; "store": { "alias": "store"; "required": false; "isSignal": true; }; "handlers": { "alias": "handlers"; "required": false; "isSignal": true; }; "threads": { "alias": "threads"; "required": false; "isSignal": true; }; "activeThreadId": { "alias": "activeThreadId"; "required": false; "isSignal": true; }; "welcomeDisabled": { "alias": "welcomeDisabled"; "required": false; "isSignal": true; }; "modelOptions": { "alias": "modelOptions"; "required": false; "isSignal": true; }; "showModelPicker": { "alias": "showModelPicker"; "required": false; "isSignal": true; }; "selectedModel": { "alias": "selectedModel"; "required": false; "isSignal": true; }; "modelPickerPlaceholder": { "alias": "modelPickerPlaceholder"; "required": false; "isSignal": true; }; "genuiToolNames": { "alias": "genuiToolNames"; "required": false; "isSignal": true; }; }, { "selectedModel": "selectedModelChange"; "threadSelected": "threadSelected"; "renderEvent": "renderEvent"; "regenerate": "regenerate"; "rate": "rate"; "messageCopy": "messageCopy"; }, never, ["[chatWelcomeSuggestions]", "[chatHeader]", "[chatToolCallTemplate]", "[chatInputModelSelect]"], true, never>;
+}
+
+declare class ChatPopupComponent {
+    readonly agent: _angular_core.InputSignal<Agent>;
+    /** A2UI component catalog forwarded to the inner <chat>. Without it,
+     * messages classified as A2UI parse correctly but never mount a
+     * surface. Pass `a2uiBasicCatalog()` from `@threadplane/chat`. */
+    readonly views: _angular_core.InputSignal<Readonly<Record<string, _angular_core.Type<unknown> | _threadplane_render.RenderViewEntry>> | undefined>;
+    /** Forwarded to the inner <chat>. When non-empty, a model picker pill
+     * renders in the chat-input chrome. */
+    readonly modelOptions: _angular_core.InputSignal<readonly ChatSelectOption[]>;
+    /**
+     * Forwarded to the inner `<chat>`. When `false`, hides the
+     * auto-rendered model picker even with non-empty `modelOptions`.
+     * Use this in narrow surfaces (the chat-sidebar panel is 28rem
+     * wide; chat-popup is 24rem) where the picker crowds the input.
+     * Defaults to `true`.
+     */
+    readonly showModelPicker: _angular_core.InputSignal<boolean>;
+    /** Two-way bound current model value. */
+    readonly selectedModel: _angular_core.ModelSignal<string>;
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /**
+     * Keyboard shortcut (single key) that toggles the popup with cmd (mac)
+     * or ctrl (other). Set to `null` to disable. Default: 'k' — matches the
+     * widely-used cmd/ctrl+K convention.
+     */
+    readonly shortcut: _angular_core.InputSignal<string | null>;
+    /** Close the popup on Escape (default true). */
+    readonly closeOnEscape: _angular_core.InputSignal<boolean>;
+    private readonly destroyRef;
+    private readonly document;
+    constructor();
+    toggle(): void;
+    openWindow(): void;
+    closeWindow(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatPopupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatPopupComponent, "chat-popup", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; "views": { "alias": "views"; "required": false; "isSignal": true; }; "modelOptions": { "alias": "modelOptions"; "required": false; "isSignal": true; }; "showModelPicker": { "alias": "showModelPicker"; "required": false; "isSignal": true; }; "selectedModel": { "alias": "selectedModel"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "shortcut": { "alias": "shortcut"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; }, { "selectedModel": "selectedModelChange"; "open": "openChange"; }, never, ["[chatHeader]", "[chatWelcomeSuggestions]"], true, never>;
+}
+
+declare class ChatSidebarComponent {
+    readonly agent: _angular_core.InputSignal<Agent>;
+    /** A2UI component catalog forwarded to the inner <chat>. Without it,
+     * messages classified as A2UI parse correctly but never mount a
+     * surface. Pass `a2uiBasicCatalog()` from `@threadplane/chat`. */
+    readonly views: _angular_core.InputSignal<Readonly<Record<string, _angular_core.Type<unknown> | _threadplane_render.RenderViewEntry>> | undefined>;
+    /** Forwarded to the inner <chat>. When non-empty, a model picker pill
+     * renders in the chat-input chrome. */
+    readonly modelOptions: _angular_core.InputSignal<readonly ChatSelectOption[]>;
+    /**
+     * Forwarded to the inner `<chat>`. When `false`, hides the
+     * auto-rendered model picker even with non-empty `modelOptions`.
+     * Use this in narrow surfaces (the chat-sidebar panel is 28rem
+     * wide; chat-popup is 24rem) where the picker crowds the input.
+     * Defaults to `true`.
+     */
+    readonly showModelPicker: _angular_core.InputSignal<boolean>;
+    /** Two-way bound current model value. */
+    readonly selectedModel: _angular_core.ModelSignal<string>;
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** Close the sidebar on Escape (default true). */
+    readonly closeOnEscape: _angular_core.InputSignal<boolean>;
+    readonly pushContent: _angular_core.InputSignal<boolean>;
+    private readonly document;
+    constructor();
+    toggle(): void;
+    openWindow(): void;
+    closeWindow(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatSidebarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatSidebarComponent, "chat-sidebar", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; "views": { "alias": "views"; "required": false; "isSignal": true; }; "modelOptions": { "alias": "modelOptions"; "required": false; "isSignal": true; }; "showModelPicker": { "alias": "showModelPicker"; "required": false; "isSignal": true; }; "selectedModel": { "alias": "selectedModel"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "pushContent": { "alias": "pushContent"; "required": false; "isSignal": true; }; }, { "selectedModel": "selectedModelChange"; "open": "openChange"; }, never, ["*", "[chatSidebarPanelTitle]", "[chatHeader]", "[chatWelcomeSuggestions]"], true, never>;
+}
+
+declare class ChatTimelineSliderComponent {
+    readonly agent: _angular_core.InputSignal<AgentWithHistory>;
+    readonly selectedIndex: _angular_core.WritableSignal<number>;
+    readonly history: _angular_core.Signal<AgentCheckpoint[]>;
+    readonly replayRequested: _angular_core.OutputEmitterRef<string>;
+    readonly forkRequested: _angular_core.OutputEmitterRef<string>;
+    replay(cp: AgentCheckpoint): void;
+    fork(cp: AgentCheckpoint, index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatTimelineSliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatTimelineSliderComponent, "chat-timeline-slider", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; }, { "replayRequested": "replayRequested"; "forkRequested": "forkRequested"; }, never, never, true, never>;
+}
+
+type ChatSidenavMode = 'expanded' | 'collapsed' | 'drawer';
+declare class ChatSidenavComponent {
+    readonly mode: _angular_core.InputSignal<ChatSidenavMode>;
+    readonly open: _angular_core.InputSignal<boolean>;
+    readonly threads: _angular_core.InputSignal<Thread[] | null>;
+    readonly activeThreadId: _angular_core.InputSignal<string | null>;
+    readonly actions: _angular_core.InputSignal<ThreadActionAdapter | null>;
+    readonly archivedThreads: _angular_core.InputSignal<Thread[] | null>;
+    readonly projects: _angular_core.InputSignal<Project[] | null>;
+    readonly selectedProjectId: _angular_core.InputSignal<string | null>;
+    readonly projectActions: _angular_core.InputSignal<ProjectActionAdapter | null>;
+    readonly agent: _angular_core.InputSignal<Agent | AgentWithHistory | null>;
+    readonly debug: _angular_core.InputSignal<boolean>;
+    readonly newChat: _angular_core.OutputEmitterRef<void>;
+    readonly threadSelected: _angular_core.OutputEmitterRef<string>;
+    readonly searchOpened: _angular_core.OutputEmitterRef<void>;
+    readonly openChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly modeChange: _angular_core.OutputEmitterRef<ChatSidenavMode>;
+    readonly projectSelected: _angular_core.OutputEmitterRef<string>;
+    readonly newProjectRequested: _angular_core.OutputEmitterRef<void>;
+    protected readonly archivedOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly showDebugButton: _angular_core.Signal<boolean>;
+    protected readonly isDebugStreaming: _angular_core.Signal<boolean>;
+    private readonly destroyRef;
+    private readonly injector;
+    private readonly debugHost;
+    private debugRef;
+    private debugOutputSubscriptions;
+    private currentDebugDock;
+    constructor();
+    protected openDebug(event: MouseEvent): void;
+    protected onEscape(): void;
+    protected onCollapseToggle(): void;
+    private ensureDebugPanel;
+    private destroyDebug;
+    private defaultDebugDock;
+    private setDebugEdgeClaim;
+    private clearDebugEdgeClaim;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatSidenavComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatSidenavComponent, "chat-sidenav", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "threads": { "alias": "threads"; "required": false; "isSignal": true; }; "activeThreadId": { "alias": "activeThreadId"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "archivedThreads": { "alias": "archivedThreads"; "required": false; "isSignal": true; }; "projects": { "alias": "projects"; "required": false; "isSignal": true; }; "selectedProjectId": { "alias": "selectedProjectId"; "required": false; "isSignal": true; }; "projectActions": { "alias": "projectActions"; "required": false; "isSignal": true; }; "agent": { "alias": "agent"; "required": false; "isSignal": true; }; "debug": { "alias": "debug"; "required": false; "isSignal": true; }; }, { "newChat": "newChat"; "threadSelected": "threadSelected"; "searchOpened": "searchOpened"; "openChange": "openChange"; "modeChange": "modeChange"; "projectSelected": "projectSelected"; "newProjectRequested": "newProjectRequested"; }, never, ["[sidenavHeader]", "[sidenavPrimary]", "[sidenavSections]", "[sidenavFooterLeft]", "[sidenavFooterRight]", "[sidenavAccount]"], true, never>;
+}
+
+/**
+ * Backdrop scrim for chat-sidenav's drawer mode, rendered as a sibling of
+ * <chat-sidenav> so its z-index sits cleanly between the page content
+ * and the drawer host (escapes the drawer host's stacking context).
+ *
+ * Usage:
+ *   <chat-sidenav-scrim [open]="drawerOpen()" (dismiss)="drawerOpen.set(false)" />
+ *   <chat-sidenav [(open)]="drawerOpen" ...></chat-sidenav>
+ */
+declare class ChatSidenavScrimComponent {
+    /** When true, render the backdrop button covering the viewport. */
+    readonly open: _angular_core.InputSignal<boolean>;
+    /** Fires when the user clicks the backdrop. */
+    readonly dismiss: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatSidenavScrimComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatSidenavScrimComponent, "chat-sidenav-scrim", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "dismiss": "dismiss"; }, never, never, true, never>;
+}
+
+type InterruptAction = 'accept' | 'edit' | 'respond' | 'ignore';
+declare class ChatInterruptPanelComponent {
+    readonly agent: _angular_core.InputSignal<Agent>;
+    readonly action: _angular_core.OutputEmitterRef<InterruptAction>;
+    readonly interrupt: _angular_core.Signal<AgentInterrupt | undefined>;
+    readonly interruptReason: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatInterruptPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatInterruptPanelComponent, "chat-interrupt-panel", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; }, { "action": "action"; }, never, never, true, never>;
+}
+
+/**
+ * Returns a CSS style string for a subagent's status badge.
+ * Kept exported for backward compatibility with existing consumers; the
+ * preferred way to style status visually is via the `data-status` attribute
+ * + CSS selectors (see component styles below).
+ */
+declare function statusColor(status: SubagentStatus): string;
+declare class ChatSubagentCardComponent {
+    readonly subagent: _angular_core.InputSignal<Subagent>;
+    readonly state: _angular_core.Signal<TraceState>;
+    readonly latestMessageContent: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatSubagentCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatSubagentCardComponent, "chat-subagent-card", never, { "subagent": { "alias": "subagent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ResolvedCitation {
+    source: 'message' | 'markdown';
+    citation: Citation;
+}
+declare class CitationsResolverService {
+    readonly message: _angular_core.WritableSignal<Message | null>;
+    readonly markdownDefs: _angular_core.WritableSignal<Map<string, CitationDefinition>>;
+    lookup(refId: string): Signal<ResolvedCitation | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CitationsResolverService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CitationsResolverService>;
+}
+
+/**
+ * Renders streaming markdown by walking a @cacheplane/partial-markdown AST
+ * through @threadplane/render's view registry.
+ *
+ * Reactivity model: the live `parser.root` keeps a stable JS reference
+ * across pushes (partial-markdown's identity guarantee). To make Angular
+ * signals propagate downstream when the underlying tree changes, we surface
+ * a materialized snapshot via `materialize()`. The snapshot shares
+ * structurally — unchanged subtrees keep the SAME reference, and any
+ * descendant change yields a NEW root reference. This lets Angular's
+ * `Object.is` equality check both detect changes (root reference differs)
+ * and short-circuit unchanged subtrees (per-node references stable).
+ *
+ * Override per-node-type renderers via the `[viewRegistry]` input or by
+ * supplying a different `MARKDOWN_VIEW_REGISTRY` provider in the injector
+ * tree.
+ */
+declare class ChatStreamingMdComponent {
+    readonly content: _angular_core.InputSignal<string>;
+    readonly streaming: _angular_core.InputSignal<boolean>;
+    readonly viewRegistry: _angular_core.InputSignal<Readonly<Record<string, _angular_core.Type<unknown> | _threadplane_render.RenderViewEntry>> | undefined>;
+    readonly resolvedRegistry: _angular_core.Signal<Readonly<Record<string, _angular_core.Type<unknown> | _threadplane_render.RenderViewEntry>>>;
+    private readonly resolver;
+    constructor();
+    private parser;
+    private prior;
+    private finished;
+    readonly root: _angular_core.Signal<MarkdownDocumentNode | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatStreamingMdComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChatStreamingMdComponent, "chat-streaming-md", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "streaming": { "alias": "streaming"; "required": false; "isSignal": true; }; "viewRegistry": { "alias": "viewRegistry"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * DI token for the markdown view registry consumed by <chat-streaming-md>
+ * and <md-children>. Maps MarkdownNode.type strings (e.g. "paragraph",
+ * "heading") to Angular components that render that node type.
+ *
+ * `<chat-streaming-md>` provides the runtime registry on its component-level
+ * injector — either the consumer-supplied [viewRegistry] input, or
+ * `cacheplaneMarkdownViews` (the default) — so descendant <md-children>
+ * components resolve the right components for each node.
+ */
+declare const MARKDOWN_VIEW_REGISTRY: InjectionToken<Readonly<Record<string, _angular_core.Type<unknown> | _threadplane_render.RenderViewEntry>>>;
+
+/**
+ * Recursively dispatches a parent node's children through the markdown view
+ * registry. Each child's `type` is looked up in the registry; the resolved
+ * component is rendered with `[node]` bound to that child.
+ *
+ * Identity-preserving: `track $any(child)` keys on the JS reference of the
+ * child node. Because @cacheplane/partial-markdown preserves node identity
+ * across pushes, unchanged subtrees never re-render.
+ */
+declare class MarkdownChildrenComponent {
+    readonly parent: _angular_core.InputSignal<MarkdownNode>;
+    private readonly registry;
+    protected readonly children: _angular_core.Signal<readonly MarkdownNode[]>;
+    protected resolve(child: MarkdownNode): Type<unknown> | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownChildrenComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownChildrenComponent, "chat-md-children", never, { "parent": { "alias": "parent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Default view registry consumed by <chat-streaming-md>. Maps every
+ * MarkdownNode.type emitted by @cacheplane/partial-markdown@0.2 to its
+ * corresponding Angular component.
+ *
+ * Override per-node-type via `withViews(cacheplaneMarkdownViews, { … })`.
+ */
+declare const cacheplaneMarkdownViews: ViewRegistry;
+
+declare class MarkdownDocumentComponent {
+    readonly node: _angular_core.InputSignal<MarkdownDocumentNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownDocumentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownDocumentComponent, "chat-md-document", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownParagraphComponent {
+    readonly node: _angular_core.InputSignal<MarkdownParagraphNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownParagraphComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownParagraphComponent, "chat-md-paragraph", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownHeadingComponent {
+    readonly node: _angular_core.InputSignal<MarkdownHeadingNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownHeadingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownHeadingComponent, "chat-md-heading", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownBlockquoteComponent {
+    readonly node: _angular_core.InputSignal<MarkdownBlockquoteNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownBlockquoteComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownBlockquoteComponent, "chat-md-blockquote", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownListComponent {
+    readonly node: _angular_core.InputSignal<MarkdownListNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownListComponent, "chat-md-list", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownListItemComponent {
+    readonly node: _angular_core.InputSignal<MarkdownListItemNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownListItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownListItemComponent, "chat-md-list-item", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownCodeBlockComponent {
+    readonly node: _angular_core.InputSignal<MarkdownCodeBlockNode>;
+    protected readonly languageClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownCodeBlockComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownCodeBlockComponent, "chat-md-code-block", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownThematicBreakComponent {
+    readonly node: _angular_core.InputSignal<MarkdownThematicBreakNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownThematicBreakComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownThematicBreakComponent, "chat-md-thematic-break", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownTextComponent {
+    readonly node: _angular_core.InputSignal<MarkdownTextNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownTextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownTextComponent, "chat-md-text", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownEmphasisComponent {
+    readonly node: _angular_core.InputSignal<MarkdownEmphasisNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownEmphasisComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownEmphasisComponent, "chat-md-emphasis", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownStrongComponent {
+    readonly node: _angular_core.InputSignal<MarkdownStrongNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownStrongComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownStrongComponent, "chat-md-strong", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownStrikethroughComponent {
+    readonly node: _angular_core.InputSignal<MarkdownStrikethroughNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownStrikethroughComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownStrikethroughComponent, "chat-md-strikethrough", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownInlineCodeComponent {
+    readonly node: _angular_core.InputSignal<MarkdownInlineCodeNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownInlineCodeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownInlineCodeComponent, "chat-md-inline-code", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownLinkComponent {
+    readonly node: _angular_core.InputSignal<MarkdownLinkNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownLinkComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownLinkComponent, "chat-md-link", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownAutolinkComponent {
+    readonly node: _angular_core.InputSignal<MarkdownAutolinkNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownAutolinkComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownAutolinkComponent, "chat-md-autolink", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownImageComponent {
+    readonly node: _angular_core.InputSignal<MarkdownImageNode>;
+    protected readonly failed: _angular_core.WritableSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownImageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownImageComponent, "chat-md-image", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownSoftBreakComponent {
+    readonly node: _angular_core.InputSignal<MarkdownSoftBreakNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownSoftBreakComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownSoftBreakComponent, "chat-md-soft-break", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownHardBreakComponent {
+    readonly node: _angular_core.InputSignal<MarkdownHardBreakNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownHardBreakComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownHardBreakComponent, "chat-md-hard-break", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownCitationReferenceComponent {
+    readonly node: _angular_core.InputSignal<MarkdownCitationReferenceNode>;
+    private readonly resolver;
+    protected readonly resolved: _angular_core.Signal<_threadplane_chat.ResolvedCitation | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownCitationReferenceComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownCitationReferenceComponent, "chat-md-citation-reference", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownTableComponent {
+    readonly node: _angular_core.InputSignal<MarkdownTableNode>;
+    protected readonly headerRow: _angular_core.Signal<MarkdownTableRowNode | null>;
+    protected readonly bodyRows: _angular_core.Signal<MarkdownTableRowNode[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownTableComponent, "chat-md-table", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownTableRowComponent {
+    readonly node: _angular_core.InputSignal<MarkdownTableRowNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownTableRowComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownTableRowComponent, "chat-md-table-row", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownTableCellComponent {
+    readonly node: _angular_core.InputSignal<MarkdownTableCellNode>;
+    private readonly isHeaderRowToken;
+    protected readonly isHeader: _angular_core.Signal<boolean>;
+    protected readonly alignment: _angular_core.Signal<_cacheplane_partial_markdown.Alignment>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownTableCellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownTableCellComponent, "chat-md-table-cell", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Provided by MarkdownTableRowComponent for header rows so that
+ * MarkdownTableCellComponent can render <th> instead of <td>.
+ * The value is a Signal<boolean> so that it tracks the row's isHeader reactively.
+ */
+declare const IS_HEADER_ROW: InjectionToken<Signal<boolean>>;
+
+declare const CHAT_MARKDOWN_STYLES = "\n  chat-streaming-md { display: block; color: var(--ngaf-chat-text); line-height: var(--ngaf-chat-line-height); }\n\n  /* Headings */\n  chat-streaming-md h1, chat-streaming-md h2, chat-streaming-md h3, chat-streaming-md h4, chat-streaming-md h5, chat-streaming-md h6 {\n    font-weight: 600;\n    line-height: 1.25;\n    margin: 1.25rem 0 0.75rem;\n  }\n  chat-streaming-md h1:first-child, chat-streaming-md h2:first-child, chat-streaming-md h3:first-child,\n  chat-streaming-md h4:first-child, chat-streaming-md h5:first-child, chat-streaming-md h6:first-child { margin-top: 0; }\n  chat-streaming-md h1 { font-size: 1.5em; font-weight: 700; }\n  chat-streaming-md h2 { font-size: 1.25em; }\n  chat-streaming-md h3 { font-size: 1.1em; }\n  chat-streaming-md h4 { font-size: 1em; }\n  chat-streaming-md h5, chat-streaming-md h6 { font-size: 0.95em; color: var(--ngaf-chat-text-muted); }\n\n  /* Paragraphs and inline emphasis */\n  chat-streaming-md p { margin: 0 0 0.75rem; line-height: 1.6; font-size: var(--ngaf-chat-font-size); }\n  chat-streaming-md p:last-child { margin-bottom: 0; }\n  chat-streaming-md strong, chat-streaming-md b { font-weight: 700; }\n  chat-streaming-md em, chat-streaming-md i { font-style: italic; }\n  chat-streaming-md del, chat-streaming-md s { text-decoration: line-through; color: var(--ngaf-chat-text-muted); }\n  chat-streaming-md mark { background: var(--ngaf-chat-surface-alt); padding: 0 2px; border-radius: 2px; }\n  chat-streaming-md sub { font-size: 0.75em; vertical-align: sub; }\n  chat-streaming-md sup { font-size: 0.75em; vertical-align: super; }\n\n  /* Links */\n  chat-streaming-md a { color: var(--ngaf-chat-primary); text-decoration: underline; text-underline-offset: 2px; }\n  chat-streaming-md a:hover { text-decoration-thickness: 2px; }\n\n  /* Lists (CommonMark + GFM task lists) */\n  chat-streaming-md ul, chat-streaming-md ol { margin: 0 0 0.75rem; padding-left: 1.5rem; }\n  chat-streaming-md ul { list-style: disc outside; }\n  chat-streaming-md ol { list-style: decimal outside; }\n  chat-streaming-md ul ul { list-style: circle outside; }\n  chat-streaming-md ul ul ul { list-style: square outside; }\n  chat-streaming-md li { margin: 0.2rem 0; }\n  chat-streaming-md li::marker { color: var(--ngaf-chat-text-muted); }\n  chat-streaming-md li > p { margin: 0 0 0.25rem; }\n  chat-streaming-md li > ul, chat-streaming-md li > ol { margin: 0.25rem 0 0; }\n  /* GFM task lists: marked emits <li><input type=\"checkbox\" disabled> ... */\n  chat-streaming-md li:has(> input[type=\"checkbox\"]) { list-style: none; margin-left: -1.25rem; }\n  chat-streaming-md li > input[type=\"checkbox\"] { margin-right: 0.5rem; vertical-align: middle; }\n\n  /* Code (inline + fenced) */\n  chat-streaming-md code {\n    background: var(--ngaf-chat-surface-alt);\n    color: var(--ngaf-chat-text);\n    padding: 1px 5px;\n    border-radius: 4px;\n    font-family: var(--ngaf-chat-font-mono);\n    font-size: 0.9em;\n  }\n  chat-streaming-md pre {\n    background: var(--ngaf-chat-surface-alt);\n    color: var(--ngaf-chat-text);\n    padding: 12px 14px;\n    border-radius: var(--ngaf-chat-radius-card);\n    overflow-x: auto;\n    font-family: var(--ngaf-chat-font-mono);\n    font-size: var(--ngaf-chat-font-size-sm);\n    line-height: 1.5;\n    margin: 0 0 0.75rem;\n  }\n  chat-streaming-md pre code { background: transparent; padding: 0; border-radius: 0; font-size: inherit; }\n\n  /* Blockquote */\n  chat-streaming-md blockquote {\n    border-left: 3px solid var(--ngaf-chat-separator);\n    padding: 0.25rem 0 0.25rem 12px;\n    margin: 0 0 0.75rem;\n    color: var(--ngaf-chat-text-muted);\n  }\n  chat-streaming-md blockquote > :last-child { margin-bottom: 0; }\n\n  /* Horizontal rule */\n  chat-streaming-md hr {\n    border: none;\n    border-top: 1px solid var(--ngaf-chat-separator);\n    margin: 1rem 0;\n  }\n\n  /* Tables (GFM) */\n  chat-streaming-md table {\n    border-collapse: collapse;\n    margin: 0 0 0.75rem;\n    width: 100%;\n    font-size: 0.95em;\n  }\n  chat-streaming-md thead { background: var(--ngaf-chat-surface-alt); }\n  chat-streaming-md th, chat-streaming-md td {\n    border: 1px solid var(--ngaf-chat-separator);\n    padding: 6px 10px;\n    text-align: left;\n    vertical-align: top;\n  }\n  chat-streaming-md th { font-weight: 600; }\n  /* Component-rendered table: chat-md-table becomes a horizontally-scrollable\n     wrapper for the inner <table>; row/cell elements stay layout-transparent\n     so the browser's table layout takes over. Without this overflow wrapper,\n     wide tables push their parent container past the viewport horizontally. */\n  chat-streaming-md chat-md-table {\n    display: block;\n    overflow-x: auto;\n    max-width: 100%;\n    margin: 0 0 0.75rem;\n  }\n  chat-streaming-md chat-md-table-row { display: contents; }\n  chat-streaming-md chat-md-table-cell { display: contents; }\n  chat-streaming-md chat-md-table > table { margin: 0; }\n  /* Task-list items: checkbox + first paragraph render inline; subsequent\n     blocks (sub-lists, multi-paragraph items) flow normally below. */\n  chat-streaming-md li.chat-md-list-item--task {\n    list-style: none;\n    margin-left: -1.25rem;\n    display: flex;\n    flex-wrap: wrap;\n    align-items: baseline;\n    gap: 0.5rem;\n  }\n  chat-streaming-md li.chat-md-list-item--task > input[type=\"checkbox\"] {\n    margin: 0;\n    flex: 0 0 auto;\n    transform: translateY(2px);\n  }\n  /* The chat-md-children wrapper around list-item content takes remaining width */\n  chat-streaming-md li.chat-md-list-item--task > chat-md-children {\n    flex: 1 1 auto;\n    min-width: 0;\n  }\n  /* Tight task items: only the FIRST paragraph aligns inline with the\n     checkbox (margin collapsed). Subsequent paragraphs/blocks keep their\n     normal vertical spacing so multi-block items render readably. */\n  chat-streaming-md li.chat-md-list-item--task > chat-md-children > chat-md-paragraph:first-child > p {\n    margin: 0;\n  }\n\n  /* Media */\n  chat-streaming-md img { max-width: 100%; height: auto; border-radius: 6px; }\n  /* Broken-image fallback: muted pill showing alt text + icon. Triggered\n     when <img> fires (error). Caught by live browser smoke \u2014 prior impl\n     showed only the browser's broken-image icon with no readable alt. */\n  chat-streaming-md .chat-md-image--broken {\n    display: inline-flex;\n    align-items: center;\n    gap: 0.4rem;\n    padding: 0.25rem 0.5rem;\n    background: var(--ngaf-chat-surface-alt);\n    border: 1px dashed var(--ngaf-chat-separator);\n    border-radius: 6px;\n    font-size: 0.9em;\n    color: var(--ngaf-chat-text-muted, currentColor);\n    opacity: 0.85;\n  }\n  chat-streaming-md .chat-md-image__icon { font-size: 1em; line-height: 1; }\n  chat-streaming-md .chat-md-image__alt { font-style: italic; }\n";
+
+/**
+ * Renders markdown content to sanitized HTML.
+ * Falls back to plain text with newline->br conversion if `marked` is not installed.
+ */
+declare function renderMarkdown(content: string, sanitizer: DomSanitizer): SafeHtml;
+
+/**
+ * Render a millisecond duration as a human-readable label suitable for
+ * the chat-reasoning "Thought for Ns" pill.
+ *
+ * - <1 s         → "<1s"
+ * - 1–59 s       → "Ns"     (e.g. "4s")
+ * - ≥60 s        → "Nm Ms"  (e.g. "1m 12s", "60m 0s")
+ *
+ * Negative or non-finite inputs collapse to "<1s" so a corrupted timing
+ * map never produces noisy output.
+ */
+declare function formatDuration(ms: number): string;
+
+/** Chevron down (▼ replacement). 12x12, stroke-based. */
+declare const ICON_CHEVRON_DOWN = "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M3 4.5L6 7.5L9 4.5\"/></svg>";
+/** Chevron up (▲ replacement). 12x12, stroke-based. */
+declare const ICON_CHEVRON_UP = "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M3 7.5L6 4.5L9 7.5\"/></svg>";
+/** Gear icon (⚙ replacement). 14x14. */
+declare const ICON_TOOL = "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><circle cx=\"12\" cy=\"12\" r=\"3\"/><path d=\"M12 1v2M12 21v2M4.22 4.22l1.42 1.42M18.36 18.36l1.42 1.42M1 12h2M21 12h2M4.22 19.78l1.42-1.42M18.36 5.64l1.42-1.42\"/></svg>";
+/** Warning triangle (⚠ replacement). 18x18. */
+declare const ICON_WARNING = "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"18\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M10.29 3.86L1.82 18a2 2 0 001.71 3h16.94a2 2 0 001.71-3L13.71 3.86a2 2 0 00-3.42 0z\"/><line x1=\"12\" y1=\"9\" x2=\"12\" y2=\"13\"/><line x1=\"12\" y1=\"17\" x2=\"12.01\" y2=\"17\"/></svg>";
+/** Robot/agent icon (replacement). 14x14. */
+declare const ICON_AGENT = "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><rect x=\"3\" y=\"11\" width=\"18\" height=\"10\" rx=\"2\"/><circle cx=\"12\" cy=\"5\" r=\"2\"/><path d=\"M12 7v4\"/><line x1=\"8\" y1=\"16\" x2=\"8\" y2=\"16\"/><line x1=\"16\" y1=\"16\" x2=\"16\" y2=\"16\"/></svg>";
+/** Check mark replacement. 12x12. */
+declare const ICON_CHECK = "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M2.5 6L5 8.5L9.5 3.5\"/></svg>";
+/** Send arrow (for chat input). 16x16. */
+declare const ICON_SEND = "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M8 12V4M8 4L4 8M8 4L12 8\"/></svg>";
+
+/** Catalog entry for the A2UI surface renderer.
+ *
+ * `component` is mounted once all of the component's bindings (data
+ * model paths referenced in its prop expressions) have resolved. While
+ * any binding is unpopulated, the `fallback` is mounted instead. If
+ * `fallback` is omitted, the lib's default fallback
+ * (`A2uiDefaultFallbackComponent`) is mounted.
+ *
+ * This is a chat-side alias for the shared `RenderViewEntry` shape so
+ * consumers of `@threadplane/chat` don't have to import from `@threadplane/render`. */
+type A2uiViewEntry = RenderViewEntry;
+/** Catalog shape accepted by `<a2ui-surface>`. Each entry is either a
+ * bare `Type<unknown>` (legacy shape — no per-component fallback) or
+ * an `A2uiViewEntry`. */
+type A2uiViews = Readonly<Record<string, Type<unknown> | A2uiViewEntry>>;
+/** Normalize a catalog entry to the `A2uiViewEntry` shape. Bare
+ * `Type<unknown>` entries are wrapped as `{ component }`; entries
+ * already in the discriminated shape are returned unchanged. */
+declare function normalizeViewEntry(entry: Type<unknown> | A2uiViewEntry): A2uiViewEntry;
+
+interface PartialArgsBridge {
+    /**
+     * Replace the cumulative argument-string buffer for `toolCallId` with
+     * `argsSoFar` and re-extract any newly-complete envelopes. The args
+     * string is expected to grow monotonically.
+     */
+    push(toolCallId: string, argsSoFar: string): void;
+    /** True if a tool_call_id has been poisoned by malformed input. */
+    isPoisoned(toolCallId: string): boolean;
+}
+/**
+ * Subscribes to LangGraph custom events of name 'a2ui-partial' and feeds
+ * the surface store envelope-by-envelope as the parent LLM streams its
+ * tool_call.arguments JSON. Uses @cacheplane/partial-json to extract
+ * structurally-complete envelope objects from the growing args string.
+ *
+ * Synthesis safety net: if the first complete surfaceUpdate arrives and
+ * no beginRendering has been extracted yet, the bridge synthesises one
+ * targeted at the surfaceUpdate's first component (preferring id='root'
+ * if present). This makes the surface mount IMMEDIATELY after the first
+ * surfaceUpdate parses — without waiting for the LLM to emit beginRendering
+ * at the end of its envelope list — so the render-element fallback gate
+ * (PR #252) actually fires while dataModelUpdates flow in.
+ *
+ * The store's apply() already treats repeated beginRendering for the same
+ * surfaceId as idempotent (just re-applies styles), so the LLM's eventual
+ * beginRendering (if any) is a no-op rather than a conflict.
+ */
+declare function createPartialArgsBridge(store: A2uiSurfaceStore): PartialArgsBridge;
+
+/**
+ * The parent LLM may emit envelope-tool arguments in four shapes (observed in
+ * the spike across gpt-5-mini and gpt-5): the canonical {envelopes: [...]},
+ * a singular typo {envelope: [...]}, positional keys {0: env, 1: env, ...}
+ * when the model treats the args as the array, or a flat single envelope.
+ * This pure function maps all four into a canonical envelope list.
+ *
+ * Strict-mode tool binding (OpenAI) should eliminate the non-canonical
+ * shapes in production, but the normalizer is the safety net.
+ */
+declare function normalizeEnvelopeArgs(args: Record<string, unknown> | null | undefined): unknown[] | null;
+
+declare class A2uiSurfaceComponent {
+    /** Wire-format surface (legacy path — kept for backwards compat). */
+    readonly surface: _angular_core.InputSignal<A2uiSurface | undefined>;
+    /** Chat-side surface state with per-component readiness. When set,
+     * this takes priority and the progressive renderer is used. */
+    readonly state: _angular_core.InputSignal<A2uiSurfaceState | undefined>;
+    readonly catalog: _angular_core.InputSignal<Readonly<Record<string, Type<unknown> | _threadplane_render.RenderViewEntry>> | Readonly<Record<string, Type<unknown> | _threadplane_render.RenderViewEntry>>>;
+    readonly handlers: _angular_core.InputSignal<Record<string, (params: Record<string, unknown>) => unknown | Promise<unknown>>>;
+    /** Optional top-level placeholder when the surface has no components
+     * yet. Defaults to A2uiDefaultFallbackComponent. */
+    readonly surfaceFallback: _angular_core.InputSignal<Type<unknown> | undefined>;
+    readonly events: _angular_core.OutputEmitterRef<RenderEvent>;
+    readonly action: _angular_core.OutputEmitterRef<A2uiActionMessage>;
+    /** Agent-set primary color from `beginRendering.styles.primaryColor`.
+     * Returns null when unset so the host binding doesn't override the
+     * consumer's `:root`-level `--a2ui-primary` default. */
+    readonly primaryColor: _angular_core.Signal<string | null>;
+    /** Agent-set font family from `beginRendering.styles.font`. Returns
+     * null when unset so the host doesn't override consumer fonts. */
+    readonly fontFamily: _angular_core.Signal<string | null>;
+    /** Roots from the surface state — components whose ids appear as
+     * children of no other component. The wire spec includes
+     * `beginRendering.root` as the single root; that path stays usable
+     * but we keep the renderer permissive in case future surfaces emit
+     * multiple top-level components.
+     *
+     * Conservative: returns only the first key from componentViews
+     * insertion order. The wire format's beginRendering.root carries the
+     * true root id; plumbing it through A2uiSurfaceState is a follow-up. */
+    readonly rootIds: _angular_core.Signal<string[]>;
+    /** Convert the A2UI surface to a json-render Spec for rendering.
+     *  Prefers `state().surface` (the progressively-built wire surface)
+     *  over the legacy `surface` input. surfaceToSpec handles
+     *  children.explicitList → spec.children translation + reserved-key
+     *  filtering + path-ref → $bindState rewriting; the rendered tree
+     *  then uses render-element's standard input-mapping
+     *  (`childKeys: el.children`) so catalog components receive the
+     *  inputs they actually declare.
+     *
+     *  This supersedes the earlier slot-based progressive renderer,
+     *  which mounted root components but never populated their
+     *  childKeys input — leaving Columns/Rows/etc. with no children. */
+    readonly spec: _angular_core.Signal<_json_render_core.Spec | null>;
+    /** Convert ViewRegistry to AngularRegistry for RenderSpecComponent. */
+    readonly registry: _angular_core.Signal<_threadplane_render.AngularRegistry>;
+    /** Merge built-in A2UI handlers with consumer-provided handlers. */
+    readonly internalHandlers: _angular_core.Signal<{
+        'a2ui:event': (params: Record<string, unknown>) => A2uiActionMessage | undefined;
+        'a2ui:localAction': (params: Record<string, unknown>) => unknown;
+    }>;
+    onRenderEvent(event: RenderEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiSurfaceComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiSurfaceComponent, "a2ui-surface", never, { "surface": { "alias": "surface"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "catalog": { "alias": "catalog"; "required": true; "isSignal": true; }; "handlers": { "alias": "handlers"; "required": false; "isSignal": true; }; "surfaceFallback": { "alias": "surfaceFallback"; "required": false; "isSignal": true; }; }, { "events": "events"; "action": "action"; }, never, never, true, never>;
+}
+
+declare function surfaceToSpec(surface: A2uiSurface): Spec | null;
+
+/** Builds an A2uiActionMessage from handler params and the current surface.
+ *  The action.context is serialized as v1 DynamicValue-wrapped entries.
+ *  Sets action.label when the source component is a Button with a Text
+ *  child whose literalString is non-empty. */
+declare function buildA2uiActionMessage(params: Record<string, unknown>, surface: A2uiSurface): A2uiActionMessage;
+
+declare function a2uiBasicCatalog(): ViewRegistry;
+
+/** Emits a data model binding event if the prop has a binding path. */
+declare function emitBinding(emit: (event: string) => void, bindings: Record<string, string> | undefined, prop: string, value: unknown): void;
+
+/** v1 textFieldType values from A2uiTextField. */
+type TextFieldType = 'date' | 'longText' | 'number' | 'shortText' | 'obscured';
+declare class A2uiTextFieldComponent {
+    private static _idCounter;
+    protected readonly _inputId: string;
+    readonly label: _angular_core.InputSignal<string>;
+    /** v1 prop: text (resolved string value). */
+    readonly text: _angular_core.InputSignal<string>;
+    /** Back-compat alias: value. surface-to-spec resolves DynamicString → plain string. */
+    readonly value: _angular_core.Signal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly textFieldType: _angular_core.InputSignal<TextFieldType>;
+    readonly validationRegexp: _angular_core.InputSignal<string>;
+    readonly _bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec | undefined>;
+    protected readonly htmlInputType: _angular_core.Signal<string>;
+    onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiTextFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiTextFieldComponent, "a2ui-text-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "textFieldType": { "alias": "textFieldType"; "required": false; "isSignal": true; }; "validationRegexp": { "alias": "validationRegexp"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class A2uiCheckBoxComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    /** v1 canonical prop: boolean checked state. */
+    readonly value: _angular_core.InputSignal<boolean | undefined>;
+    /** Pre-v1 alias retained for back-compat. */
+    readonly checked: _angular_core.InputSignal<boolean>;
+    readonly _bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec | undefined>;
+    protected readonly effectiveValue: _angular_core.Signal<boolean>;
+    onChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiCheckBoxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiCheckBoxComponent, "a2ui-check-box", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class A2uiButtonComponent {
+    /** v1: child Text component is rendered inside the button via childKeys. */
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec>;
+    readonly primary: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    handleClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiButtonComponent, "a2ui-button", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "primary": { "alias": "primary"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Resolved option shape — label and value are plain strings after surface-to-spec resolves them. */
+interface ResolvedOption {
+    label: string;
+    value: string;
+}
+declare class A2uiMultipleChoiceComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    /** Resolved current selections from surface-to-spec. Normalized in
+     * `selectionsArray` because LLMs sometimes seed the data model with a
+     * scalar (e.g. `"5"`) instead of an array (`["5"]`); we coerce so
+     * .includes() works either way. */
+    readonly selections: _angular_core.InputSignal<string | string[] | undefined>;
+    protected readonly selectionsArray: _angular_core.Signal<string[]>;
+    /** Resolved options with plain string labels (surface-to-spec resolves DynamicString). */
+    readonly options: _angular_core.InputSignal<ResolvedOption[]>;
+    /** When ≤ 1 — render as single-select <select>; otherwise multi-select checkboxes. */
+    readonly maxAllowedSelections: _angular_core.InputSignal<number>;
+    readonly _bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec | undefined>;
+    protected readonly isSingleSelect: _angular_core.Signal<boolean>;
+    protected isSelected(value: string): boolean;
+    onSelectChange(event: Event): void;
+    onCheckChange(value: string, event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiMultipleChoiceComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiMultipleChoiceComponent, "a2ui-multiple-choice", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "selections": { "alias": "selections"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "maxAllowedSelections": { "alias": "maxAllowedSelections"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class A2uiSliderComponent {
+    private static _idCounter;
+    protected readonly _inputId: string;
+    readonly label: _angular_core.InputSignal<string>;
+    /** v1 prop: value (resolved DynamicNumber). */
+    readonly value: _angular_core.InputSignal<number>;
+    /** v1 prop: minValue. */
+    readonly minValue: _angular_core.InputSignal<number>;
+    /** v1 prop: maxValue. */
+    readonly maxValue: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly _bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec | undefined>;
+    onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiSliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiSliderComponent, "a2ui-slider", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class A2uiDateTimeInputComponent {
+    private static _idCounter;
+    protected readonly _inputId: string;
+    readonly label: _angular_core.InputSignal<string>;
+    /** v1 prop: value (resolved DynamicString). */
+    readonly value: _angular_core.InputSignal<string>;
+    /** v1 prop: enableDate — include date portion. */
+    readonly enableDate: _angular_core.InputSignal<boolean>;
+    /** v1 prop: enableTime — include time portion. */
+    readonly enableTime: _angular_core.InputSignal<boolean>;
+    readonly _bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec | undefined>;
+    /** Derives HTML input type from enableDate + enableTime. */
+    protected readonly htmlInputType: _angular_core.Signal<string>;
+    onChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiDateTimeInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiDateTimeInputComponent, "a2ui-date-time-input", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "enableDate": { "alias": "enableDate"; "required": false; "isSignal": true; }; "enableTime": { "alias": "enableTime"; "required": false; "isSignal": true; }; "_bindings": { "alias": "_bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type UsageHint = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'caption' | 'body';
+declare class A2uiTextComponent {
+    readonly text: _angular_core.InputSignal<string>;
+    readonly usageHint: _angular_core.InputSignal<UsageHint>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec | undefined>;
+    protected cssClass(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiTextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiTextComponent, "a2ui-text", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; "usageHint": { "alias": "usageHint"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class A2uiIconComponent {
+    /** v1 canonical prop. */
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    /** Pre-v1 alias retained for back-compat. */
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<number | null>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec | undefined>;
+    protected readonly effectiveName: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiIconComponent, "a2ui-icon", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** v1 fit values mapped 1:1 to CSS object-fit. */
+type ImageFit = 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
+/** v1 usageHint maps to a sizing preset. The component renders fluid by
+ * default; usageHint sets a max-width / aspect-ratio to match common
+ * intents. */
+type ImageUsageHint = 'icon' | 'avatar' | 'smallFeature' | 'mediumFeature' | 'largeFeature' | 'header';
+declare class A2uiImageComponent {
+    readonly url: _angular_core.InputSignal<string>;
+    readonly alt: _angular_core.InputSignal<string>;
+    readonly width: _angular_core.InputSignal<number | null>;
+    readonly height: _angular_core.InputSignal<number | null>;
+    /** v1 prop: CSS object-fit equivalent. */
+    readonly fit: _angular_core.InputSignal<ImageFit | undefined>;
+    /** v1 prop: sizing preset. */
+    readonly usageHint: _angular_core.InputSignal<ImageUsageHint | undefined>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec | undefined>;
+    protected explicitWidth(): string | null;
+    protected explicitHeight(): string | null;
+    protected hintStyle(): {
+        maxWidth: string;
+        aspectRatio?: string;
+        borderRadius?: string;
+    } | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiImageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiImageComponent, "a2ui-image", never, { "url": { "alias": "url"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "fit": { "alias": "fit"; "required": false; "isSignal": true; }; "usageHint": { "alias": "usageHint"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type ColumnAlignment = 'start' | 'center' | 'end' | 'stretch';
+declare class A2uiColumnComponent {
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec>;
+    readonly gap: _angular_core.InputSignal<number>;
+    readonly alignment: _angular_core.InputSignal<ColumnAlignment>;
+    readonly distribution: _angular_core.InputSignal<"center" | "start" | "end" | "spaceBetween" | "spaceAround" | "spaceEvenly">;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    protected readonly alignItems: _angular_core.Signal<string>;
+    /** Convert the Tailwind gap unit (multiples of 4px) to pixels. */
+    protected readonly gapPx: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiColumnComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiColumnComponent, "a2ui-column", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "distribution": { "alias": "distribution"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type RowAlignment = 'start' | 'center' | 'end' | 'stretch';
+type RowDistribution = 'start' | 'center' | 'end' | 'space-between' | 'space-around';
+declare class A2uiRowComponent {
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec>;
+    readonly gap: _angular_core.InputSignal<number>;
+    readonly alignment: _angular_core.InputSignal<RowAlignment>;
+    readonly distribution: _angular_core.InputSignal<RowDistribution>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    protected readonly alignItems: _angular_core.Signal<string>;
+    protected readonly justifyContent: _angular_core.Signal<string>;
+    /** Convert the gap unit (multiples of 4px) to pixels. */
+    protected readonly gapPx: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiRowComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiRowComponent, "a2ui-row", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "distribution": { "alias": "distribution"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class A2uiCardComponent {
+    /** v1: a single child key, delivered via childKeys[0] from the render framework. */
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiCardComponent, "a2ui-card", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class A2uiDividerComponent {
+    /** Canonical v1 spec name. The LLM emits this. */
+    readonly axis: _angular_core.InputSignal<"horizontal" | "vertical" | undefined>;
+    /** Older alias retained for json-render usage and back-compat. */
+    readonly direction: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /** Effective axis — `axis` wins if provided, otherwise fall back to `direction`. */
+    protected readonly orientation: _angular_core.Signal<"horizontal" | "vertical">;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiDividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiDividerComponent, "a2ui-divider", never, { "axis": { "alias": "axis"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class A2uiListComponent {
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec>;
+    readonly direction: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /** v1 canonical prop: cross-axis alignment. */
+    readonly alignment: _angular_core.InputSignal<"center" | "start" | "end" | "stretch" | undefined>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    protected readonly listClass: _angular_core.Signal<"a2ui-list--horizontal" | "a2ui-list--vertical">;
+    protected readonly alignmentCss: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiListComponent, "a2ui-list", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class A2uiModalComponent {
+    /**
+     * v1: childKeys[0] = entryPointChild (inline trigger),
+     *     childKeys[1] = contentChild (modal body).
+     */
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec>;
+    /** Resolved title string (from optional title DynamicString). */
+    readonly title: _angular_core.InputSignal<string>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly entryPointKey: _angular_core.Signal<string>;
+    protected readonly contentKey: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiModalComponent, "a2ui-modal", never, { "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class A2uiTabsComponent {
+    /** Resolved tab titles from tabItems[*].title — produced by surface-to-spec. */
+    readonly tabTitles: _angular_core.InputSignal<string[]>;
+    /** v1: each child key corresponds to a tab's contentChild (childKeys[i] ↔ tabTitles[i]). */
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    constructor();
+    protected readonly activeChildKey: _angular_core.Signal<string | null>;
+    selectTab(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiTabsComponent, "a2ui-tabs", never, { "tabTitles": { "alias": "tabTitles"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": true; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class A2uiAudioPlayerComponent {
+    readonly url: _angular_core.InputSignal<string>;
+    /** v1 canonical prop: short description / title rendered above the player. */
+    readonly description: _angular_core.InputSignal<string>;
+    /** v1 prop name: autoPlay (camelCase). */
+    readonly autoPlay: _angular_core.InputSignal<boolean>;
+    readonly controls: _angular_core.InputSignal<boolean>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiAudioPlayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiAudioPlayerComponent, "a2ui-audio-player", never, { "url": { "alias": "url"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "autoPlay": { "alias": "autoPlay"; "required": false; "isSignal": true; }; "controls": { "alias": "controls"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class A2uiVideoComponent {
+    readonly url: _angular_core.InputSignal<string>;
+    /** v1 prop name: autoPlay (camelCase). */
+    readonly autoPlay: _angular_core.InputSignal<boolean>;
+    readonly controls: _angular_core.InputSignal<boolean>;
+    readonly bindings: _angular_core.InputSignal<Record<string, string>>;
+    readonly emit: _angular_core.InputSignal<(event: string) => void>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly childKeys: _angular_core.InputSignal<string[]>;
+    readonly spec: _angular_core.InputSignal<Spec | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<A2uiVideoComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<A2uiVideoComponent, "a2ui-video", never, { "url": { "alias": "url"; "required": false; "isSignal": true; }; "autoPlay": { "alias": "autoPlay"; "required": false; "isSignal": true; }; "controls": { "alias": "controls"; "required": false; "isSignal": true; }; "bindings": { "alias": "bindings"; "required": false; "isSignal": true; }; "emit": { "alias": "emit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "childKeys": { "alias": "childKeys"; "required": false; "isSignal": true; }; "spec": { "alias": "spec"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface MockAgent extends Agent {
+    messages: WritableSignal<Message[]>;
+    status: WritableSignal<AgentStatus>;
+    isLoading: WritableSignal<boolean>;
+    error: WritableSignal<unknown>;
+    toolCalls: WritableSignal<ToolCall[]>;
+    state: WritableSignal<Record<string, unknown>>;
+    interrupt?: WritableSignal<AgentInterrupt | undefined>;
+    subagents?: WritableSignal<Map<string, Subagent>>;
+    history?: WritableSignal<AgentCheckpoint[]>;
+    events$: Observable<AgentEvent>;
+    /**
+     * Minimal lifecycle stub the chat lib's effects subscribe to. We only
+     * model the signals the chat composition currently reads; richer adapter
+     * lifecycles (langgraph, ag-ui) extend this contract on their own mocks.
+     * The public `lifecycle` view is a readonly signal; tests drive the
+     * value via `_internal.streamStartedAt.set(...)` below.
+     */
+    lifecycle: {
+        streamStartedAt: Signal<number | null>;
+    };
+    /**
+     * Test-only escape hatch for driving lifecycle signals from a spec. Mirrors
+     * the `_internal` pattern used by CHAT_LIFECYCLE so tests can flip the
+     * underlying writable without going through a full submit/stream cycle.
+     */
+    _internal: {
+        streamStartedAt: WritableSignal<number | null>;
+    };
+    /** Captured calls to submit() in order. */
+    submitCalls: Array<{
+        input: AgentSubmitInput;
+        opts?: AgentSubmitOptions;
+    }>;
+    /** Count of stop() invocations. */
+    stopCount: number;
+}
+interface MockAgentOptions {
+    messages?: Message[];
+    status?: AgentStatus;
+    isLoading?: boolean;
+    error?: unknown;
+    toolCalls?: ToolCall[];
+    state?: Record<string, unknown>;
+    withInterrupt?: boolean;
+    withSubagents?: boolean;
+    history?: AgentCheckpoint[];
+    events$?: Observable<AgentEvent>;
+}
+declare function mockAgent(opts?: MockAgentOptions): MockAgent;
+
+export { A2uiAudioPlayerComponent, A2uiButtonComponent, A2uiCardComponent, A2uiCheckBoxComponent, A2uiColumnComponent, A2uiDateTimeInputComponent, A2uiDividerComponent, A2uiIconComponent, A2uiImageComponent, A2uiListComponent, A2uiModalComponent, A2uiMultipleChoiceComponent, A2uiRowComponent, A2uiSliderComponent, A2uiSurfaceComponent, A2uiTabsComponent, A2uiTextComponent, A2uiTextFieldComponent, A2uiVideoComponent, CHAT_CONFIG, CHAT_LIFECYCLE, CHAT_MARKDOWN_STYLES, ChatCitationCardTemplateDirective, ChatCitationsCardComponent, ChatCitationsComponent, ChatComponent, ChatConfirmDialogComponent, ChatErrorComponent, ChatGenerativeUiComponent, ChatGenuiSkeletonComponent, ChatHistorySearchPaletteComponent, ChatInputComponent, ChatInterruptComponent, ChatInterruptPanelComponent, ChatLauncherButtonComponent, ChatMessageActionsComponent, ChatMessageComponent, ChatMessageListComponent, ChatOverflowMenuComponent, ChatPopupComponent, ChatProjectListComponent, ChatReasoningComponent, ChatScrollBubbleComponent, ChatSelectComponent, ChatSidebarComponent, ChatSidenavComponent, ChatSidenavScrimComponent, ChatStreamingMdComponent, ChatSubagentCardComponent, ChatSubagentsComponent, ChatSuggestionsComponent, ChatThreadListComponent, ChatTimelineComponent, ChatTimelineSliderComponent, ChatToolCallCardComponent, ChatToolCallTemplateDirective, ChatToolCallsComponent, ChatTraceComponent, ChatTypingIndicatorComponent, ChatWelcomeComponent, ChatWelcomeSuggestionComponent, ChatWindowComponent, CitationsResolverService, ICON_AGENT, ICON_CHECK, ICON_CHEVRON_DOWN, ICON_CHEVRON_UP, ICON_SEND, ICON_TOOL, ICON_WARNING, IS_HEADER_ROW, MARKDOWN_VIEW_REGISTRY, MarkdownAutolinkComponent, MarkdownBlockquoteComponent, MarkdownChildrenComponent, MarkdownCitationReferenceComponent, MarkdownCodeBlockComponent, MarkdownDocumentComponent, MarkdownEmphasisComponent, MarkdownHardBreakComponent, MarkdownHeadingComponent, MarkdownImageComponent, MarkdownInlineCodeComponent, MarkdownLinkComponent, MarkdownListComponent, MarkdownListItemComponent, MarkdownParagraphComponent, MarkdownSoftBreakComponent, MarkdownStrikethroughComponent, MarkdownStrongComponent, MarkdownTableCellComponent, MarkdownTableComponent, MarkdownTableRowComponent, MarkdownTextComponent, MarkdownThematicBreakComponent, MessageTemplateDirective, a2uiBasicCatalog, buildA2uiActionMessage, cacheplaneMarkdownViews, createA2uiSurfaceStore, createContentClassifier, createParseTreeStore, createPartialArgsBridge, emitBinding, extractErrorMessage, formatDuration, getInterrupt, getMessageType, isAssistantMessage, isSystemMessage, isToolMessage, isTyping, isUserMessage, messageContent, mockAgent, normalizeEnvelopeArgs, normalizeViewEntry, provideChat, renderMarkdown, statusColor, submitMessage, surfaceToSpec };
+export type { A2uiComponentView, A2uiSurfaceState, A2uiSurfaceStore, A2uiViewEntry, A2uiViews, Agent, AgentCheckpoint, AgentCustomEvent, AgentEvent, AgentInterrupt, AgentRuntimeTelemetryEvent, AgentRuntimeTelemetryPayload, AgentRuntimeTelemetryProperties, AgentRuntimeTelemetrySink, AgentStateUpdateEvent, AgentStatus, AgentSubmitInput, AgentSubmitOptions, AgentWithHistory, ChatConfig, ChatLifecycle, ChatMessageRole, ChatRenderEvent, ChatScrollBubbleMode, ChatSelectOption, ChatSidenavMode, ChatToolCallTemplateContext, Citation, ContentBlock, ContentClassifier, ContentType, ElementAccumulationState, InterruptAction, Message, MessageTemplateType, MockAgent, MockAgentOptions, OverflowMenuItem, ParseTreeStore, PartialArgsBridge, Project, ProjectActionAdapter, ResolvedCitation, Role, Subagent, SubagentStatus, Thread, ThreadActionAdapter, ThreadMatch, ToolCall, ToolCallInfo, ToolCallStatus, TraceState };