tui

type AllDoneMsg struct{}

type AnnotationEnrichment struct {
	CIStatuses          map[string]*github.CheckStatus
	EmptyWorktrees      map[string]*engine.WorktreeInfo
	WorktreeByStackRoot map[string]*engine.WorktreeInfo
}

type BaseModel = core.BaseModel

type BranchChoice struct {
	Display string // What to show (may include tree visualization)
	Value   string // Actual branch name
}

type CompleteMsg struct {
	Success bool   // True if operation succeeded
	Summary string // Summary message to display
	Error   error  // Error if Success is false
}

type Direction string

type DirectionSelectModel struct {
	// contains filtered or unexported fields
}

type FileGroup struct {
	File   string
	Hunks  []int // Indices into the items slice
	Binary bool  // Is this a binary file?
}

type FlattenExcludedBranch struct {
	Branch string // Branch name
	Reason string // Why it was kept in place
}

type FlattenPlannedMove struct {
	Branch    string // Branch being moved
	OldParent string // Current parent branch
	NewParent string // Target parent branch (closer to trunk)
}

type FlattenPreviewData struct {
	Moves            []FlattenPlannedMove    // Branches that will be moved
	UnchangedCount   int                     // Number of branches that won't change
	ExcludedBranches []FlattenExcludedBranch // Branches excluded due to conflicts
}

type Handler interface {
	// IsInteractive returns true if this handler supports interactive prompts.
	// Interactive handlers can pause the TUI for user input.
	IsInteractive() bool

	// Cleanup performs any necessary cleanup. Safe to call multiple times.
	// For interactive handlers, this typically delegates to the Runner.
	Cleanup()
}

type HunkItem struct {
	Hunk       git.Hunk
	Selected   bool
	Expanded   bool // Manual expand/collapse override
	Splittable bool // Can this hunk be split further?
}

type HunkSelectorModel struct {
	core.BaseModel // Embedded for ReadySignaler interface
	// contains filtered or unexported fields
}

type LogMode int

type LogModel struct {
	// contains filtered or unexported fields
}

type LogOptions struct {
	Style               string
	ShowUntracked       bool
	Exclude             map[string]bool                  // Branches to exclude from selection
	NonSelectable       map[string]bool                  // Branches visible but not selectable (cursor skips them)
	AnnotationOverrides map[string]tree.BranchAnnotation // Override annotations (e.g., add custom labels)
	Logger              output.Logger                    // Optional logger for IO timing diagnostics
	Header              string                           // Custom header text for selection mode (e.g., "Select new parent for branch X")
	SkipEnrichment      bool                             // Skip background GitHub/git enrichment for faster startup
	Inline              bool                             // Run inline without alt-screen (doesn't take over terminal)

	// ValidateSelection is called (with debounce) when selection changes to validate the current selection.
	// If provided, the result is displayed in the UI footer.
	ValidateSelection func(branchName string) *SelectionValidation
}

type MessageRecorder struct {
	// contains filtered or unexported fields
}

type MockRunner struct {
	// contains filtered or unexported fields
}

type MoveModel struct {
	// contains filtered or unexported fields
}

type MoveModelConfig struct {
	SourceBranch string          // Branch being moved
	Descendants  []engine.Branch // Descendants that will be restacked
	OldParent    *engine.Branch  // Current parent branch
	OldParentRev string          // Current parent revision for rebase specs
	Validator    MoveValidator   // Validation function for conflict checking
}

type MovePreviewData struct {
	SourceBranch   string   // Branch being moved
	OldParent      string   // Current parent branch
	NewParent      string   // Target parent branch
	Commits        []string // Commit subjects that will be moved
	Descendants    []string // Descendant branches that will be restacked
	HasConflicts   bool     // Whether the move will cause conflicts
	ConflictBranch string   // Which branch would have conflicts (if any)
	ConflictError  string   // Error message describing the conflict
}

type MoveResult struct {
	SelectedParent string              // The branch selected as new parent
	RebaseSpecs    []engine.RebaseSpec // Precomputed rebase specs for the selection
	Canceled       bool                // Whether the user canceled
}

type MoveValidation struct {
	Valid          bool                // Whether the move is valid (no conflicts)
	Message        string              // Status message
	Commits        []string            // Commits that will be moved
	HasConflicts   bool                // Whether conflicts were detected
	ConflictBranch string              // Branch with conflicts
	ConflictError  string              // Conflict error message
	RebaseSpecs    []engine.RebaseSpec // Precomputed rebase specs for this selection
}

type MoveValidator func(ontoBranch string) (*MoveValidation, error)

type PanicError struct {
	Source string // Name of the operation that panicked
	Err    error  // The panic value wrapped as an error
	Stack  string // Stack trace at the time of panic
}

type PhaseHandler interface {
	ProgressHandler

	// StartPhase begins a named phase.
	// Only one phase can be active at a time.
	StartPhase(phase string)

	// PhaseDetail adds a detail line to the current phase.
	// Use this for per-item progress within a phase.
	PhaseDetail(phase, detail string)

	// CompletePhase marks a phase as done.
	// Call this before starting the next phase.
	CompletePhase(phase string)
}

type PhaseMsg struct {
	Phase  string // Name of the phase
	Status Status // Current status of the phase
	Detail string // Optional detail message
}

type ProgressHandler interface {
	Handler

	// Start initializes progress tracking with total operations.
	// Call this at the beginning of the operation.
	Start(totalOps int)

	// Progress updates the current progress.
	// completed should be <= total passed to Start().
	Progress(completed, total int)

	// Complete signals completion with a summary message.
	// Call this when the operation is done.
	Complete(summary string)
}

type ProgressMsg struct {
	Completed int // Number of completed operations
	Total     int // Total number of operations
}

type PromptHandler interface {
	Handler

	// SupportsPrompts returns true if this handler can show prompts.
	// This is typically the same as IsInteractive(), but allows for
	// handlers that are interactive but don't support prompts.
	SupportsPrompts() bool
}

type ReadySignaler = core.ReadySignaler

type Runner struct {
	// contains filtered or unexported fields
}

type SelectOption struct {
	Label string // What to show
	Value string // Value to return
}

type SelectionValidation struct {
	Valid   bool   // Whether the selection is valid (no conflicts)
	Message string // Status message to display (e.g., "Move will complete without conflicts")
}

type Sender interface {
	// Send sends a message to the TUI model.
	Send(msg tea.Msg)

	// Pause pauses TUI rendering for interactive prompts.
	Pause()

	// Resume resumes TUI rendering after a pause.
	Resume()

	// Wait blocks until the TUI exits.
	Wait()

	// Cleanup performs terminal cleanup.
	Cleanup()

	// IsHealthy returns true if the TUI is running and responsive.
	IsHealthy() bool
}

type Status = core.Status

type Story struct {
	Name        string
	Category    string
	Description string
	CreateModel func() tea.Model
}

type SubmitResultMsg struct {
	Idx   int
	URL   string
	Error error
}

type SubmitTUIModel struct {
	// contains filtered or unexported fields
}

type WorktreeData struct {
	EmptyWorktrees      map[string]*engine.WorktreeInfo // Anchor branches with no children
	WorktreeByStackRoot map[string]*engine.WorktreeInfo // Stack root -> worktree info
}