harness-tui-kit

use harness_tui_kit;

pub mod components;

pub mod util;

pub use effects::KitEffect;

pub use theme::{Theme, ThemeOverrides, DEFAULT_THEME};

pub use types::{
    AgentInfo, AgentStatus, ApprovalAction, ApprovalRequest, ChatMessage, CommandHint, CostEntry,
    DecisionOption, DiffLine, DiffLineKind, KeyShortcut, LatencySnapshot, LogEntry, LogLevel,
    PaletteItem, PermissionCategory, PermissionDecision, PermissionRequest, ProposalInfo,
    ProposalKind, ProposalStatus, RiskLevel, Role, Severity, TaskItem, TaskStatus, ToolCallInfo,
    ToolCallStatus, TransactionEntry, TreasuryInfo, VoteChoice, WorkflowEdge, WorkflowNodeInfo,
    WorkflowNodeKind,
};

pub use components::agent::{
    AgentAvatar, AgentCard, AgentCardState, AgentList, AgentListState, AgentPanel, AgentPanelState,
    AgentStatusDot, AvatarSize, MultiAgentHeader, MultiAgentHeaderState,
};

pub use components::chat::{
    ChangeKind, ChatBubble, ChatBubbleState, ChatTimeline, ChatTimelineState, CodeBlock,
    CodeBlockState, DiffView, DiffViewState, DocumentPreviewPane, DocumentPreviewState,
    FileDisplay, FileDisplayState, InlineDiffCard, InputBar, InputBarState, MarkdownRenderer,
    MarkdownStreamCollector, PageStyle, StreamingText, StreamingTextState, ToolCallCard,
    ToolCallCardStatus, ToolCallDisplay, ToolCallState,
};

pub use components::governance::{
    ConstitutionView, ConstitutionViewState, ProposalCard, ProposalCardState, TreasuryDisplay,
    VotingPanel, VotingPanelState,
};

pub use components::harness::{
    AttributionTable, AttributionTableRow, AttributionTaskOutcomeBadge, ChangeManifestView,
    HarnessComponentRow, HarnessComponentStatus, HarnessComponentTree, HarnessComponentTreeState,
    ManifestEntryView, ManifestVerdictBadge,
};

pub use components::history::{
    ApprovalCell, ApprovalState, AssistantCell, DiffCell, ExecCell, ExecOutcome, HistoryCell,
    HistoryView, HistoryViewState, SystemCell, SystemSeverity, ToolCell, ToolCellOutcome, UserCell,
};

pub use components::hitl::{
    ApprovalChooser, ApprovalChooserAction, ApprovalChooserState, ApprovalDialog,
    ApprovalDialogState, ApprovalQueue, ApprovalQueueState, ConfirmButton, ConfirmationPrompt,
    ConfirmationPromptState, DecisionPanel, DecisionPanelState, PermissionBanner, PermissionPrompt,
    PermissionPromptState,
};

pub use components::metrics::{
    CostTracker, LatencyDisplay, MetricBarItem, MetricCard, MetricsBar, TokenMeter,
};

pub use components::system::{
    custom_logo::CLAUSEN_LOGO_ROWS, fmt_elapsed_compact, AppShell, AppShellState, Banner,
    BlockLogo, CollapseState, CommandPalette, CommandPaletteState, CustomLogo, FocusCard,
    GoalDisplay, GoalStep, GoalStepStatus, HintBar, HintItem, KeyboardHelp, KeyboardHelpState,
    LogViewer, LogViewerState, Modal, ModalButton, ModalState, ModelCapabilities, ModelPicker,
    ModelPickerRow, ModelPickerState, NotificationToast, NotificationToastState, PagerOverlay,
    PagerOverlayState, PendingSelection, ResumePicker, ResumePickerRow, ResumePickerState,
    SettingsPalette, SettingsPaletteItem, SettingsPalettePage, SettingsPaletteState, ShellPanel,
    Shimmer, ShimmerState, SlashDropdown, SlashDropdownItem, SlashDropdownState, Spinner,
    SpinnerStyle, SplitDirection, SplitPane, SplitPaneState, StatusBar, StatusFooter,
    StatusFooterIndicator, StatusIndicator, StatusIndicatorState, StatusKind, TabItem, Tabs,
    TabsState, ThemePicker, ThemePickerRow, ThemePickerState, ThinkingAnimation,
    ThinkingAnimationState, ThinkingIndicator, ToastMessage, WelcomeConfig, WelcomeScreen,
    BLOCK_LOGO_GLYPH_WIDTH, BLOCK_LOGO_HEIGHT, BLOCK_LOGO_SPACING, SHIMMER_DEFAULT_WINDOW,
    THINKING_ANIMATION_DEFAULT_CHARSET, THINKING_ANIMATION_DEFAULT_WIDTH,
};

pub use components::workflow::{
    ProgressTimeline, TaskList, TaskListState, WorkflowDAG, WorkflowDAGState, WorkflowNode,
};

pub use util::live_wrap::{display_width, wrap_unicode};

pub use util::unified_diff::{parse_unified_diff, DiffFile};

pub use util::word_diff::{pair_changed_lines, word_diff, ChangedPair, WordDiff};

#[derive(Debug, Clone)]
pub struct AgentPanel<'a> {

}

#[must_use]
pub fn new(info: &'a AgentInfo) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn show_metrics(mut self, show: bool) -> Self;

#[must_use]
pub fn show_tools(mut self, show: bool) -> Self;

#[must_use]
pub fn current_task(mut self, task: &'a str) -> Self;

#[must_use]
pub fn tokens_used(mut self, tokens: u64) -> Self;

#[must_use]
pub fn cost_display(mut self, cost: &'a str) -> Self;

#[must_use]
pub fn latency_ms(mut self, ms: u64) -> Self;

#[must_use]
pub fn tools(mut self, names: &'a [&'a str]) -> Self;

#[derive(Debug, Clone, Default)]
pub struct AgentPanelState {

}

pub fn scroll_up(&mut self);

pub fn scroll_down(&mut self);

#[must_use]
pub fn scroll_offset(&self) -> usize;

pub fn reset(&mut self);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum AvatarSize {
    /// 1 character wide, 1 row tall.
    Small,
    /// 3 characters wide, 3 rows tall.
    Medium,
    /// 5 characters wide, 5 rows tall.
    Large,
}

#[derive(Debug, Clone)]
pub struct AgentAvatar<'a> {

}

#[must_use]
pub fn new(id: &'a str, name: &'a str) -> Self;

#[must_use]
pub fn size(mut self, size: AvatarSize) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[derive(Debug, Clone)]
pub struct AgentCard<'a> {

}

#[must_use]
pub fn new(info: &'a AgentInfo) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[derive(Debug, Clone, Default)]
pub struct AgentCardState {
/// Whether to show expanded (multi-line) or compact (single-line) mode.

pub expanded: bool
}

pub fn toggle(&mut self);

pub fn reset(&mut self);

#[derive(Debug, Clone)]
pub struct AgentList<'a> {

}

#[must_use]
pub fn new(agents: &'a [AgentInfo]) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[derive(Debug, Clone)]
pub struct AgentListState {
/// Currently selected agent index (if any).

pub selected: Option<usize>,
/// Scroll offset for the list.

pub scroll_offset: usize,
/// Optional filter text.

pub filter: String,
/// Whether to show agents in compact mode.

pub compact: bool
}

#[must_use]
pub fn new() -> Self;

pub fn select_next(&mut self, total: usize);

pub fn select_prev(&mut self, total: usize);

pub fn set_filter(&mut self, text: impl AsRef<str>);

pub fn clear_filter(&mut self);

pub fn toggle_compact(&mut self);

#[must_use]
pub fn selected_agent<'a>(&self, agents: &'a [AgentInfo]) -> Option<&'a AgentInfo>;

pub mod agent_panel;

pub use agent_panel::{AgentPanel, AgentPanelState};

pub use avatar::{AgentAvatar, AvatarSize};

pub use card::{AgentCard, AgentCardState};

pub use list::{AgentList, AgentListState};

pub use multi_agent_header::{MultiAgentHeader, MultiAgentHeaderState};

pub use status::AgentStatusDot;

#[derive(Debug, Clone)]
pub struct MultiAgentHeader<'a> {

}

#[derive(Debug, Clone, Default)]
pub struct MultiAgentHeaderState {

}

#[must_use]
pub fn new(agents: &'a [AgentInfo]) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn focused_index(mut self, index: Option<usize>) -> Self;

#[must_use]
pub fn new() -> Self;

pub fn scroll_left(&mut self);

pub fn scroll_right(&mut self, agent_count: usize);

pub fn reset(&mut self);

#[must_use]
pub fn scroll_offset(&self) -> usize;

#[derive(Debug, Clone)]
pub struct AgentStatusDot<'a> {

}

#[must_use]
pub fn new(status: AgentStatus) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn with_label(mut self, show: bool) -> Self;

#[derive(Debug, Clone)]
pub struct ChatBubble<'a> {

}

#[must_use]
pub fn new(message: &'a ChatMessage) -> Self;

#[must_use]
pub fn markdown(mut self, enabled: bool) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn show_timestamp(mut self, show: bool) -> Self;

#[must_use]
pub fn show_sender(mut self, show: bool) -> Self;

#[must_use]
pub fn max_lines(mut self, max: usize) -> Self;

#[derive(Debug, Clone, Default)]
pub struct ChatBubbleState {
/// Scroll offset within the message content.

pub scroll_offset: usize,
/// Whether this bubble is currently selected.

pub selected: bool
}

pub fn scroll_up(&mut self);

pub fn scroll_down(&mut self);

pub fn reset(&mut self);

#[derive(Debug, Clone)]
pub struct CodeBlock<'a> {

}

#[must_use]
pub fn new(code: &'a str) -> Self;

#[must_use]
pub fn language(mut self, lang: &'a str) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn show_line_numbers(mut self, show: bool) -> Self;

#[must_use]
pub fn show_header(mut self, show: bool) -> Self;

#[derive(Debug, Clone, Default)]
pub struct CodeBlockState {
/// Vertical scroll offset (in lines).

pub scroll_offset: usize,
/// Horizontal scroll offset (in columns).

pub h_scroll: usize
}

pub fn scroll_up(&mut self);

pub fn scroll_down(&mut self);

pub fn scroll_left(&mut self);

pub fn scroll_right(&mut self);

pub fn reset(&mut self);

#[derive(Debug, Clone)]
pub struct DiffView<'a> {

}

#[must_use]
pub fn new(lines: &'a [DiffLine]) -> Self;

#[must_use]
pub fn filename(mut self, name: &'a str) -> Self;

#[must_use]
pub fn unified(mut self, value: bool) -> Self;

#[must_use]
pub fn context_lines(mut self, n: usize) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[derive(Debug, Clone, Default)]
pub struct DiffViewState {
/// Vertical scroll offset in rendered rows.

pub scroll_offset: usize
}

#[must_use]
pub fn new() -> Self;

pub fn scroll_up(&mut self);

pub fn scroll_down(&mut self);

pub fn reset(&mut self);

pub fn clamp(&mut self, max_offset: usize) -> usize;

#[derive(Debug, Clone, Default)]
pub struct DocumentPreviewState {

}

#[must_use]
pub fn scroll(&self) -> u16;

#[must_use]
pub fn follow_tail(&self) -> bool;

pub fn set_follow_tail(&mut self, on: bool);

pub fn line_up(&mut self);

pub fn line_down(&mut self);

pub fn page_up(&mut self, viewport_h: u16);

pub fn page_down(&mut self, viewport_h: u16);

pub fn jump_top(&mut self);

pub fn jump_bottom(&mut self, content_h: u16, viewport_h: u16);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum PageStyle {
    /// Subtle bordered chrome with page-number footer.
    #[default]
    Page,
    /// Raw scrollable region with no border.
    Plain,
}

#[derive(Debug, Clone)]
pub struct DocumentPreviewPane<'a> {

}

#[must_use]
pub fn new(lines: &'a [Line<'static>]) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn title(mut self, title: &'a str) -> Self;

#[must_use]
pub fn page_style(mut self, style: PageStyle) -> Self;

#[must_use]
pub fn page_number(mut self, n: u16) -> Self;

#[must_use]
pub fn total_pages(mut self, n: u16) -> Self;

#[must_use]
pub fn doc_type(mut self, label: &'a str) -> Self;

#[derive(Debug, Clone)]
pub struct FileDisplay<'a> {

}

#[must_use]
pub fn new(filename: &'a str, content: &'a str) -> Self;

#[must_use]
pub fn language(mut self, lang: &'a str) -> Self;

#[must_use]
pub fn file_size(mut self, bytes: u64) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[derive(Debug, Clone, Default)]
pub struct FileDisplayState {

}

pub fn scroll_up(&mut self);

pub fn scroll_down(&mut self);

pub fn toggle_collapse(&mut self);

pub fn reset(&mut self);

pub fn scroll_to(&mut self, line: usize);

#[must_use]
pub fn is_collapsed(&self) -> bool;

#[must_use]
pub fn scroll_offset(&self) -> usize;

#[derive(Debug, Clone)]
pub struct InlineDiffCard<'a> {

}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ChangeKind {
    /// File was modified in place.
    #[default]
    Edit,
    /// File was created from scratch.
    Create,
    /// File was deleted.
    Delete,
    /// File was renamed (or moved).
    Rename,
}

#[must_use]
pub fn new(file: &'a str, lines: &'a [DiffLine]) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn kind(mut self, kind: ChangeKind) -> Self;

#[must_use]
pub fn footer_hint(mut self, hint: &'a str) -> Self;

#[must_use]
pub fn max_body_rows(mut self, rows: u16) -> Self;

#[must_use]
pub fn suggested_height(&self) -> u16;

#[derive(Debug, Clone)]
pub struct InputBar<'a> {

}

#[must_use]
pub fn new() -> Self;

#[must_use]
pub fn bg_color(mut self, color: ratatui::style::Color) -> Self;

#[must_use]
pub fn show_prompt(mut self, show: bool) -> Self;

#[must_use]
pub fn show_top_border(mut self, show: bool) -> Self;

#[must_use]
pub fn placeholder(mut self, text: &'a str) -> Self;

#[must_use]
pub fn disabled(mut self, disabled: bool) -> Self;

#[must_use]
pub fn show_char_count(mut self, show: bool) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[derive(Debug, Clone, Default)]
pub struct InputBarState {

}

#[must_use]
pub fn text(&self) -> &str;

pub fn take_text(&mut self) -> String;

pub fn set_text(&mut self, text: impl Into<String>);

pub fn insert_char(&mut self, ch: char);

pub fn delete_char_before(&mut self);

pub fn move_cursor_left(&mut self);

pub fn move_cursor_right(&mut self);

pub fn history_prev(&mut self);

pub fn history_next(&mut self);

#[must_use]
pub fn char_count(&self) -> usize;

#[must_use]
pub fn is_empty(&self) -> bool;

pub fn clear(&mut self);

#[derive(Debug, Clone)]
pub struct MarkdownRenderer<'a> {

}

#[must_use]
pub fn new(content: &'a str) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn wrap_width(mut self, width: usize) -> Self;

#[derive(Debug, Clone)]
pub struct MarkdownStreamCollector {

}

#[must_use]
pub fn new() -> Self;

#[must_use]
pub fn with_cwd(mut self, cwd: &Path) -> Self;

#[must_use]
pub fn max_bytes(mut self, max_bytes: usize) -> Self;

#[must_use]
pub fn cwd(&self) -> Option<&Path>;

#[must_use]
pub fn overflowed(&self) -> bool;

pub fn push_delta(&mut self, delta: &str);

pub fn commit_complete_source(&mut self) -> Option<String>;

#[must_use]
pub fn full_source(&self) -> &str;

#[must_use]
pub fn committed_source(&self) -> &str;

#[must_use]
pub fn pending_source(&self) -> &str;

#[must_use]
pub fn len(&self) -> usize;

#[must_use]
pub fn is_empty(&self) -> bool;

pub fn finalize_and_drain_source(&mut self) -> String;

pub fn clear(&mut self);

pub use bubble::{ChatBubble, ChatBubbleState};

pub use code_block::{CodeBlock, CodeBlockState};

pub use diff_view::{DiffView, DiffViewState};

pub use document_preview::{DocumentPreviewPane, DocumentPreviewState, PageStyle};

pub use file_display::{FileDisplay, FileDisplayState};

pub use inline_diff_card::{ChangeKind, InlineDiffCard};

pub use input::{InputBar, InputBarState};

pub use markdown::MarkdownRenderer;

pub use markdown_stream::MarkdownStreamCollector;

pub use streaming::{StreamingText, StreamingTextState};

pub use timeline::{ChatTimeline, ChatTimelineState};

pub use tool_call::{ToolCallDisplay, ToolCallState};

pub use tool_call_card::{ToolCallCard, ToolCallCardStatus};

#[derive(Debug, Clone)]
pub struct StreamingText<'a> {

}

#[must_use]
pub fn new() -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn show_cursor(mut self, show: bool) -> Self;

#[must_use]
pub fn tick(mut self, tick: usize) -> Self;

#[derive(Debug, Clone)]
pub struct StreamingTextState {

}

#[must_use]
pub fn new(text: impl Into<String>) -> Self;

#[must_use]
pub fn full_text(&self) -> &str;

#[must_use]
pub fn revealed_text(&self) -> &str;

pub fn reveal(&mut self, n: usize);

pub fn reveal_all(&mut self);

pub fn append(&mut self, text: &str);

pub fn pause(&mut self);

pub fn resume(&mut self);

#[must_use]
pub fn is_paused(&self) -> bool;

#[must_use]
pub fn is_completed(&self) -> bool;

#[must_use]
pub fn revealed_count(&self) -> usize;

#[must_use]
pub fn total_count(&self) -> usize;

pub fn scroll_up(&mut self);

pub fn scroll_down(&mut self);

pub fn reset(&mut self);

#[derive(Debug, Clone)]
pub struct ChatTimeline<'a> {

}

#[must_use]
pub fn new(messages: &'a [ChatMessage]) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[derive(Debug, Clone, Default)]
pub struct ChatTimelineState {

}

#[must_use]
pub fn new() -> Self;

#[must_use]
pub fn messages(&self) -> &[ChatMessage];

#[must_use]
pub fn message_count(&self) -> usize;

pub fn push_message(&mut self, message: ChatMessage);

pub fn update_streaming(&mut self, delta: &str);

pub fn scroll_up(&mut self);

pub fn scroll_down(&mut self);

pub fn scroll_to_bottom(&mut self);

pub fn scroll_to_top(&mut self);

pub fn select(&mut self, index: usize);

pub fn deselect(&mut self);

#[must_use]
pub fn is_auto_scroll(&self) -> bool;

pub fn clear(&mut self);

#[derive(Debug, Clone)]
pub struct ToolCallDisplay<'a> {

}

#[must_use]
pub fn new(info: &'a ToolCallInfo) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[derive(Debug, Clone, Default)]
pub struct ToolCallState {
/// Whether the arguments section is expanded.

pub args_expanded: bool,
/// Whether the output section is expanded.

pub output_expanded: bool
}

pub fn toggle_args(&mut self);

pub fn toggle_output(&mut self);

pub fn reset(&mut self);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ToolCallCardStatus {
    /// Queued but not yet executing.
    #[default]
    Pending,
    /// Currently executing.
    Running,
    /// Finished successfully.
    Success,
    /// Finished with an error.
    Failure,
}

#[derive(Debug, Clone)]
pub struct ToolCallCard<'a> {

}

#[must_use]
pub fn new(name: &'a str) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn status(mut self, status: ToolCallCardStatus) -> Self;

#[must_use]
pub fn tick(mut self, tick: u8) -> Self;

#[must_use]
pub fn summary(mut self, summary: &'a str) -> Self;

#[must_use]
pub fn detail(mut self, detail: &'a str) -> Self;

#[must_use]
pub fn result(mut self, result: &'a str) -> Self;

#[must_use]
pub fn elapsed(mut self, label: &'a str) -> Self;

#[must_use]
pub fn measured_height(&self) -> u16;

#[derive(Debug, Clone)]
pub struct ConstitutionView<'a> {

}

#[must_use]
pub fn new(text: &'a str) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn sections(mut self, sections: &'a [(&'a str, usize)]) -> Self;

#[derive(Debug, Clone, Default)]
pub struct ConstitutionViewState {

}

pub fn scroll_up(&mut self);

pub fn scroll_down(&mut self);

pub fn jump_to_section(&mut self, index: usize, sections: &[(&str, usize)]);

pub fn next_section(&mut self, sections: &[(&str, usize)]);

pub fn prev_section(&mut self, sections: &[(&str, usize)]);

#[must_use]
pub fn scroll_offset(&self) -> usize;

#[must_use]
pub fn selected_section(&self) -> usize;

pub fn reset(&mut self);

pub mod constitution_view;

pub mod proposal_card;

pub mod treasury_display;

pub mod voting_panel;

pub use constitution_view::{ConstitutionView, ConstitutionViewState};

pub use proposal_card::{ProposalCard, ProposalCardState};

pub use treasury_display::TreasuryDisplay;

pub use voting_panel::{VotingPanel, VotingPanelState};

#[derive(Debug, Clone)]
pub struct ProposalCard<'a> {

}

#[must_use]
pub fn new(proposal: &'a ProposalInfo) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn compact(mut self, compact: bool) -> Self;

#[derive(Debug, Clone, Default)]
pub struct ProposalCardState {

}

pub fn toggle_expand(&mut self);

#[must_use]
pub fn is_expanded(&self) -> bool;

pub fn reset(&mut self);

#[derive(Debug, Clone)]
pub struct TreasuryDisplay<'a> {

}

#[must_use]
pub fn new(treasury: &'a TreasuryInfo) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn max_transactions(mut self, max: usize) -> Self;

#[derive(Debug, Clone)]
pub struct VotingPanel<'a> {

}

#[must_use]
pub fn new(proposal: &'a ProposalInfo) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn current_vote(mut self, vote: Option<VoteChoice>) -> Self;

#[derive(Debug, Clone, Default)]
pub struct VotingPanelState {

}

pub fn select_next(&mut self);

pub fn select_prev(&mut self);

#[must_use]
pub fn confirm(&self) -> Option<VoteChoice>;

#[must_use]
pub fn selected_index(&self) -> usize;

pub fn reset(&mut self);

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AttributionTaskOutcomeBadge {
    /// Task passed.
    Pass,
    /// Task failed.
    Fail,
    /// Task did not run.
    NotRun,
}

#[derive(Debug, Clone)]
pub struct AttributionTableRow {
/// Task name.

pub task: String,
/// Outcome before the iteration's edits.

pub before: AttributionTaskOutcomeBadge,
/// Outcome after the iteration's edits.

pub after: AttributionTaskOutcomeBadge
}

#[must_use]
pub fn is_fix(&self) -> bool;

#[must_use]
pub fn is_regression(&self) -> bool;

#[derive(Debug, Clone)]
pub struct AttributionTable<'a> {

}

#[must_use]
pub fn new(rows: &'a [AttributionTableRow]) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn title(mut self, title: &'a str) -> Self;

#[must_use]
pub fn no_border(mut self) -> Self;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HarnessComponentStatus {
    /// Editable + currently in sync with the last commit.
    Clean,
    /// Editable + has uncommitted edits in the current iteration.
    Dirty,
    /// Read-only — the runtime owns it (e.g. `ShortTermMemory`).
    ReadOnly,
}

#[derive(Debug, Clone)]
pub struct HarnessComponentRow {
/// Stable id (e.g. `"system_prompt"`). The SDK consumer sets

/// this from `HarnessComponentKind::as_key()`.

pub id: String,
/// Human-readable label (e.g. `"system prompt"`).

pub label: String,
/// Mount path relative to the workspace root.

pub mount: String,
/// Status badge.

pub status: HarnessComponentStatus,
/// Number of edits applied to this component in the current

/// iteration. Rendered as `+N` next to the label.

pub edit_count: u32
}

#[derive(Debug, Clone, Default)]
pub struct HarnessComponentTreeState {

}

#[must_use]
pub fn selected(&self) -> usize;

pub fn move_down(&mut self, len: usize);

pub fn move_up(&mut self);

pub fn reset(&mut self);

#[derive(Debug, Clone)]
pub struct HarnessComponentTree<'a> {

}

#[must_use]
pub fn new(rows: &'a [HarnessComponentRow]) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn title(mut self, title: &'a str) -> Self;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ManifestVerdictBadge {
    /// Edit not yet evaluated (this iteration's fresh manifest).
    Pending,
    /// `AttributionDecision::Confirmed`.
    Confirmed,
    /// `AttributionDecision::PartiallyConfirmed`.
    PartiallyConfirmed,
    /// `AttributionDecision::Refuted`.
    Refuted,
    /// `AttributionDecision::UnfalsifiableContract`.
    UnfalsifiableContract,
}

#[derive(Debug, Clone)]
pub struct ManifestEntryView {
/// Entry id (uuid-as-string).

pub id: String,
/// One-line summary of the targeted fix.

pub targeted_fix: String,
/// Diagnosed root cause.

pub root_cause: String,
/// Free-form list of failure evidence items.

pub failure_evidence: Vec<String>,
/// Tasks the contract claims will be fixed.

pub expected_fixes: Vec<String>,
/// Tasks the contract flags as at-risk for regression.

pub at_risk_regressions: Vec<String>,
/// Verdict badge.

pub verdict: ManifestVerdictBadge,
/// Component label (e.g. `"system prompt"`) the edit targets.

pub component_label: String,
/// Path the edit touched.

pub edit_path: String
}

#[derive(Debug, Clone)]
pub struct ChangeManifestView {

}

#[must_use]
pub fn new(entry: ManifestEntryView) -> Self;

#[must_use]
pub fn entry(&self) -> &ManifestEntryView;

pub use attribution_table::{AttributionTable, AttributionTableRow, AttributionTaskOutcomeBadge};

pub use component_tree::{
    HarnessComponentRow, HarnessComponentStatus, HarnessComponentTree, HarnessComponentTreeState,
};

pub use manifest_view::{ChangeManifestView, ManifestEntryView, ManifestVerdictBadge};

#[derive(Debug, Clone, PartialEq)]
pub enum ApprovalState {
    /// The agent is waiting for the user's decision.
    Pending,
    /// The user resolved the request.
    Resolved(PermissionDecision),
}

#[derive(Debug, Clone)]
pub struct ApprovalCell {

}

#[must_use]
pub fn pending(request: PermissionRequest) -> Self;

#[must_use]
pub fn resolved(request: PermissionRequest, decision: PermissionDecision) -> Self;

#[must_use]
pub fn request(&self) -> &PermissionRequest;

#[must_use]
pub fn state(&self) -> &ApprovalState;

#[derive(Debug, Clone)]
pub struct AssistantCell {

}

#[must_use]
pub fn new(sender: impl Into<String>, body: impl Into<String>) -> Self;

#[must_use]
pub fn sender_style(mut self, style: Style) -> Self;

#[must_use]
pub fn continuation(mut self) -> Self;

#[must_use]
pub fn body(&self) -> &str;

#[must_use]
pub fn sender(&self) -> &str;

pub trait HistoryCell: Debug + Send + Sync {
    /// The logical lines displayed in the main chat viewport.
    fn display_lines(&self, width: u16) -> Vec<Line<'static>>;

    /// Number of viewport rows needed to render this cell at `width`.
    /// Defaults to the count of logical lines returned by
    /// [`Self::display_lines`]. Override when the cell wraps content
    /// or contains lines wider than `width`.
    fn desired_height(&self, width: u16) -> u16 ;

    /// Lines for the transcript overlay (e.g. Ctrl+T in Codex).
    /// Defaults to [`Self::display_lines`]; override when the
    /// transcript representation should differ (e.g. `ExecCell` may
    /// show every grouped command in transcript mode but only the
    /// most-recent in viewport mode).
    fn transcript_lines(&self, width: u16) -> Vec<Line<'static>> ;

    /// Coarse "animation tick" for cells whose rendered output depends
    /// on elapsed time (spinners, shimmer effects). Returning `Some`
    /// signals that any cached transcript output should be invalidated
    /// once the tick changes; returning `None` (the default) means the
    /// cell renders identically across frames.
    fn transcript_animation_tick(&self) -> Option<u64> ;

    /// True when this cell continues a stream from the previous cell.
    /// Used by the view to suppress redundant headers / dividers
    /// between consecutive assistant deltas. Defaults to `false`.
    fn is_stream_continuation(&self) -> bool ;
}

#[derive(Debug, Clone)]
pub struct DiffCell {

}

#[must_use]
pub fn new(file: DiffFile) -> Self;

#[must_use]
pub fn from_unified_diff(source: &str) -> Vec<Self>;

#[must_use]
pub fn hide_summary(mut self) -> Self;

#[must_use]
pub fn file(&self) -> &DiffFile;

#[derive(Debug, Clone)]
pub enum ExecOutcome {
    /// Command still running.
    Running,
    /// Command finished with the given exit code and (possibly empty)
    /// captured stdout+stderr.
    Finished {
        /// Process exit code (0 = success).
        exit_code: i32,
        /// Aggregated stdout + stderr output.
        output: String,
        /// Wall-clock duration.
        duration: Duration,
    },
}

#[derive(Debug, Clone)]
pub struct ExecCell {

}

#[must_use]
pub fn new(command: impl AsRef<str>) -> Self;

#[must_use]
pub fn cwd(mut self, cwd: impl Into<String>) -> Self;

#[must_use]
pub fn with_outcome(mut self, outcome: ExecOutcome) -> Self;

#[derive(Debug, Clone, Default)]
pub struct HistoryViewState {

}

#[must_use]
pub fn following() -> Self;

#[must_use]
pub fn is_following(&self) -> bool;

pub fn set_follow(&mut self, follow: bool);

pub fn scroll_up(&mut self, rows: u16);

pub fn scroll_down(&mut self, rows: u16);

pub fn jump_to_latest(&mut self);

#[derive(Debug, Clone)]
pub struct HistoryView<'a> {

}

#[must_use]
pub fn new(cells: &'a [Box<dyn HistoryCell>]) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn total_height(&self, width: u16) -> u32;

pub use approval_cell::{ApprovalCell, ApprovalState};

pub use assistant_cell::AssistantCell;

pub use cell::HistoryCell;

pub use diff_cell::DiffCell;

pub use exec_cell::{ExecCell, ExecOutcome};

pub use history_view::{HistoryView, HistoryViewState};

pub use system_cell::{SystemCell, SystemSeverity};

pub use tool_cell::{ToolCell, ToolCellOutcome};

pub use user_cell::UserCell;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SystemSeverity {
    /// Informational notice (default).
    Info,
    /// Non-fatal warning.
    Warn,
    /// Error that did not crash the agent but the user should see.
    Error,
    /// Successful state change (operation completed, login granted).
    Success,
}

#[derive(Debug, Clone)]
pub struct SystemCell {

}

#[must_use]
pub fn new(severity: SystemSeverity, body: impl Into<String>) -> Self;

#[must_use]
pub fn info(body: impl Into<String>) -> Self;

#[must_use]
pub fn warn(body: impl Into<String>) -> Self;

#[must_use]
pub fn error(body: impl Into<String>) -> Self;

#[must_use]
pub fn success(body: impl Into<String>) -> Self;

#[must_use]
pub fn severity(&self) -> SystemSeverity;

#[must_use]
pub fn body(&self) -> &str;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ToolCellOutcome {
    /// Tool call still running — shows a "running…" suffix.
    Running,
    /// Tool returned successfully.
    Success,
    /// Tool failed.
    Failed,
}

#[derive(Debug, Clone)]
pub struct ToolCell {

}

#[must_use]
pub fn new(tool_name: impl Into<String>, input: impl AsRef<str>) -> Self;

#[must_use]
pub fn with_outcome(
        mut self,
        outcome: ToolCellOutcome,
        output: impl AsRef<str>,
        duration_ms: Option<u64>,
    ) -> Self;

pub fn set_expanded(&mut self, expanded: bool);

#[must_use]
pub fn is_expanded(&self) -> bool;

#[derive(Debug, Clone)]
pub struct UserCell {

}

#[must_use]
pub fn new(body: impl Into<String>) -> Self;

#[must_use]
pub fn prefix_style(mut self, style: Style) -> Self;

#[must_use]
pub fn body_style(mut self, style: Style) -> Self;

#[must_use]
pub fn body(&self) -> &str;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ApprovalChooserAction {
    /// Approve this specific request once.
    AllowOnce,
    /// Approve every request matching the suggested glob for the
    /// rest of the session.
    ApproveForSession,
    /// Approve every request matching the suggested glob, and
    /// persist the rule (e.g. write to `plugins.toml`).
    ApproveForPrefix,
    /// Decline this request.
    Decline,
    /// Open the linked thread / fullscreen detail view (Codex's
    /// "open fullscreen" escape hatch for big payloads).
    OpenThread,
}

#[derive(Debug, Clone, Default)]
pub struct ApprovalChooserState {

}

#[must_use]
pub fn focused(&self) -> ApprovalChooserAction;

pub fn move_next(&mut self);

pub fn move_prev(&mut self);

pub fn reset(&mut self);

#[must_use]
pub fn handle_key(&mut self, ev: &KeyEvent) -> Option<ApprovalChooserAction>;

#[derive(Debug, Clone)]
pub struct ApprovalChooser<'a> {

}

#[must_use]
pub fn new(request: &'a PermissionRequest) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[derive(Debug, Clone, Default)]
pub struct ApprovalDialogState {

}

pub fn select_next(&mut self);

pub fn select_prev(&mut self);

pub fn start_edit(&mut self);

pub fn cancel_edit(&mut self);

#[must_use]
pub fn confirm(&self) -> Option<ApprovalAction>;

pub fn append_char(&mut self, ch: char);

pub fn delete_char(&mut self);

pub fn reset(&mut self);

#[must_use]
pub const fn selected_action(&self) -> usize;

#[must_use]
pub fn edit_text(&self) -> &str;

#[must_use]
pub const fn is_editing(&self) -> bool;

#[derive(Debug, Clone)]
pub struct ApprovalDialog<'a> {

}

#[must_use]
pub fn new(request: &'a ApprovalRequest) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn show_agent_name(mut self, show: bool) -> Self;

#[derive(Debug, Clone, Default)]
pub struct ApprovalQueueState {

}

pub fn select_next(&mut self, len: usize);

pub fn select_prev(&mut self);

#[must_use]
pub const fn selected_index(&self) -> usize;

#[must_use]
pub const fn scroll_offset(&self) -> usize;

pub fn reset(&mut self);

#[derive(Debug, Clone)]
pub struct ApprovalQueue<'a> {

}

#[must_use]
pub fn new(requests: &'a [ApprovalRequest]) -> Self;

#[must_use]
pub fn theme(mut self, theme: &'a Theme) -> Self;

#[must_use]
pub fn show_position(mut self, show: bool) -> Self;