core

type ActionProvider interface {
	ContextActions() []menu.Entry
}

type BackMsg struct{}

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

type BreadcrumbUpdateMsg struct {
	Items []string
}

type ClearSearchMsg struct{}

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

type Common struct {
	// DataSource is the Kafka data source
	DataSource api.KafkaDataSource

	// Styles contains all application styles
	Styles *stylesPkg.Styles

	// Layout contains the current layout configuration
	Layout *layout.Layout

	// LayoutConfig contains layout configuration options
	LayoutConfig *layout.LayoutConfig

	// Config contains UI configuration
	Config *UIConfig

	// AppConfig is the effective kafui-owned configuration (read-only flags,
	// optional integrations, UI prefs). Never nil.
	AppConfig *appconfig.Config

	// Redactor masks secrets when displaying configuration.
	Redactor *appconfig.Redactor

	// Collector is the background cluster statistics collector (may be nil in
	// lightweight/test contexts; callers must nil-check).
	Collector *cluster.Collector

	// MetricsCollector is the background metrics collector feeding the metrics
	// page (may be nil in lightweight/test contexts; callers must nil-check).
	MetricsCollector *metrics.Collector

	// Gate is the local authorization gate. Nil in lightweight/test contexts,
	// which means allow-all (see Can). Pages must query permissions through the
	// Can/AuthzEnabled/ActiveProfileName helpers, never a global.
	Gate *authz.Gate

	// Identity is the acting local user (OS user), shown in the header and
	// whoami view and recorded in the audit log.
	Identity string

	// InitialResource is the CLI --resource deep-link (UI-9), consumed once by
	// the main page at construction time so the sidebar/breadcrumb reflect it
	// from the start (BUG-7) instead of racing an async switch against the
	// page's own default-resource Init().
	InitialResource string
}

type Component interface {
	// Init initializes the component and returns an initial command.
	Init() tea.Cmd

	// Update handles messages and returns updated component and commands.
	Update(msg tea.Msg) (tea.Model, tea.Cmd)

	// View renders the component to a string.
	View() string

	// SetDimensions sets the component's dimensions.
	SetDimensions(width, height int)
}

type ComponentConfig struct {
	// ID is a unique identifier for the component
	ID string

	// Width and Height set initial dimensions
	Width  int
	Height int

	// Common context for accessing shared dependencies
	Common *Common
}

type ComponentWithLayout interface {
	Component

	// GetLayout returns the component's layout rectangle.
	GetLayout() layout.Rectangle

	// SetLayout sets the component's layout rectangle.
	SetLayout(rect layout.Rectangle)
}

type ConfigReloadedMsg struct {
	Config interface{} // *appconfig.Config
}

type ConfirmResolvedMsg struct {
	Confirmed bool
}

type ConnectionState uint8

type ConsumerGroupsLoadErrorMsg struct {
	Error error
}

type ConsumerGroupsLoadedMsg struct {
	Groups []api.ConsumerGroup
}

type ConsumptionErrorMsg struct {
	TopicName string
	Error     error
}

type ConsumptionStartedMsg struct {
	TopicName string
}

type ConsumptionStoppedMsg struct {
	TopicName string
}

type ContextsLoadErrorMsg struct {
	Error error
}

type ContextsLoadedMsg struct {
	Contexts []string
}

type DataErrorMsg struct {
	Type  string
	Error error
}

type DataLoadedMsg struct {
	Type string
	Data interface{}
}

type DataLoader interface {
	LoadData() tea.Cmd
	RefreshData() tea.Cmd
}

type DetailPageCloseMsg struct{}

type DetailPageOpenMsg struct {
	ResourceID   string
	ResourceType string
	Data         interface{}
}

type Dimensions struct {
	Width  int
	Height int
}

type DimensionsUpdateMsg struct {
	Width  int
	Height int
}

type EventHandler interface {
	HandleKeyEvent(msg tea.KeyMsg) tea.Cmd
	HandleDataEvent(msg DataLoadedMsg) tea.Cmd
	HandleErrorEvent(msg DataErrorMsg) tea.Cmd
	HandleTimerEvent(msg TimerTickMsg) tea.Cmd
}

type FilterAppliedMsg struct {
	Count int
	Query string
}

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

type FocusState uint8

type Focusable interface {
	// Focus gives focus to the component
	Focus() tea.Cmd

	// Blur removes focus from the component
	Blur() tea.Cmd

	// IsFocused returns whether the component currently has focus
	IsFocused() bool

	// GetID returns a unique identifier for the component
	GetID() string

	// CanFocus returns whether the component can receive focus
	CanFocus() bool
}

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

type HelpBinding struct {
	Key         string
	Description string
	Important   bool // Highlight important bindings
}

type HelpSection struct {
	Title    string
	Bindings []HelpBinding
}

type HelpStyles struct {
	Container    lipgloss.Style
	Title        lipgloss.Style
	SectionTitle lipgloss.Style
	KeyBinding   lipgloss.Style
	Description  lipgloss.Style
	Footer       lipgloss.Style
	Separator    lipgloss.Style
}

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

type InputModeReporter interface {
	IsInputMode() bool
}

type KeyBinding struct {
	Key  key.Binding
	Help string
}

type KeyHandler interface {
	HandleKey(key tea.KeyMsg) tea.Cmd
	GetKeyBindings() []key.Binding
}

type KeyScoper interface {
	KeyScope() keys.Scope
}

type LoadingMsg struct {
	Active bool
	Label  string
}

type LoadingState uint8

type MessageConsumeErrorMsg struct {
	Error error
}

type MessageConsumedMsg struct {
	Message interface{}
}

type MessagesConsumedMsg struct {
	Messages []api.Message
}

type NotificationMsg struct {
	Severity StatusType
	Title    string
	Message  string
	Sticky   bool // when true, does not auto-dismiss
}

type Page interface {
	Init() tea.Cmd
	Update(msg tea.Msg) (tea.Model, tea.Cmd)
	View() string
	SetDimensions(width, height int)
	GetID() string

	// Navigation methods for enhanced routing
	GetTitle() string
	GetHelp() []key.Binding
	HandleNavigation(msg tea.Msg) (Page, tea.Cmd)
	OnFocus() tea.Cmd
	OnBlur() tea.Cmd
}

type PageChangeMsg struct {
	PageID string
	Data   interface{}
}

type PaletteProvider interface {
	PaletteEntries() []menu.Entry
}

type QuitMsg struct{}

type RefreshDataMsg struct {
	Type string
}

type ResourceChangeMsg struct {
	ResourceType string
	Data         interface{}
}

type ResourceLoadMsg struct {
	ResourceType string
}

type ResourceManager interface {
	LoadResources() tea.Cmd
	GetCurrentResourceType() string
	SwitchResource(resourceType string) tea.Cmd
}

type ResourceSelectedMsg struct {
	ResourceID   string
	ResourceType string
	Item         interface{}
}

type RetryCommand struct {
	// Command to execute
	Cmd tea.Cmd

	// Retry configuration
	Config RetryConfig

	// Current retry state
	State *RetryState

	// Error handler called on each retry
	OnError func(err error, attempt int) tea.Cmd

	// Success handler called on success
	OnSuccess func(result tea.Msg) tea.Cmd
}

type RetryConfig struct {
	// MaxRetries is the maximum number of retry attempts
	MaxRetries int

	// InitialDelay is the delay before the first retry
	InitialDelay time.Duration

	// MaxDelay is the maximum delay between retries
	MaxDelay time.Duration

	// Multiplier is the factor by which the delay increases
	Multiplier float64

	// Jitter adds randomness to prevent thundering herd
	Jitter float64
}

type RetryError struct {
	// Original error
	Err error

	// Attempt number when this error occurred
	Attempt int

	// Max retries configured
	MaxRetries int
}

type RetryState struct {
	// Current attempt number (0-based)
	Attempt int

	// Last error encountered
	LastError error

	// Next retry time
	NextRetry time.Time

	// Config for this retry operation
	Config RetryConfig
}

type RetryableOperation[T any] struct {
	// Operation to execute
	Operation func() (T, error)

	// Retry configuration
	Config RetryConfig
}

type SchemasLoadErrorMsg struct {
	Error error
}

type SchemasLoadedMsg struct {
	Schemas []api.SchemaInfo
}

type SearchMode int

type SearchModeChangeMsg struct {
	Mode SearchMode
}

type SearchMsg struct {
	Query string
	Mode  SearchMode
}

type ShowConfirmMsg struct {
	Title        string
	Message      string
	Danger       bool
	ConfirmLabel string
	OnConfirm    tea.Cmd
}

type SidebarToggledMsg struct {
	Visible bool
}

type StatefulPage interface {
	Page
	GetState() UIState
	GetFocusState() FocusState
	SetState(UIState)
	SetFocusState(FocusState)
}

type StatusBarConfig struct {
	// ShowByDefault indicates whether status bar should be visible
	ShowByDefault bool

	// DefaultTTL is the default time-to-live for messages
	DefaultTTL time.Duration

	// MaxMessageLength is the maximum length of a message before truncation
	MaxMessageLength int
}

type StatusMessage struct {
	// Type of status message
	Type StatusType

	// Message to display
	Message string

	// TTL is the time-to-live for the message (0 = no auto-dismiss)
	TTL time.Duration

	// Timestamp when the message was created
	Timestamp time.Time
}

type StatusMsg struct {
	Message string
	Type    StatusType
}

type StatusType int

type Theme struct {
	Primary   string
	Secondary string
	Accent    string
	Error     string
	Success   string
	Warning   string
	Info      string
}

type TimerTickMsg struct {
	Time time.Time
	ID   string
}

type TopicSelectedMsg struct {
	TopicName string
	Topic     interface{}
}

type TopicsLoadErrorMsg struct {
	Error error
}

type TopicsLoadedMsg struct {
	Topics map[string]api.Topic
}

type UIConfig struct {
	// ShowSidebar indicates whether sidebar should be shown by default
	ShowSidebar bool

	// CompactMode indicates whether compact layout mode is enabled
	CompactMode bool

	// Theme name (e.g., "dark", "light")
	Theme string

	// ScreenshotDir is the directory for debug screenshots (defaults to temp dir)
	ScreenshotDir string

	// ConsumerGroupRefreshInterval is the auto-refresh interval selected on the
	// consumer-group detail page (0 = off). Persisted for the session so the
	// choice survives re-opening the page.
	// ponytail: session-scoped only — writing it back to the on-disk kafui config
	// is deferred to the application-config feature.
	ConsumerGroupRefreshInterval time.Duration
}

type UIState uint8

type Unwinder interface {
	Unwind() (tea.Cmd, bool)
}

type ViewRenderer interface {
	Render(model interface{}) string
	SetTheme(theme Theme)
	SetDimensions(width, height int)
}

type WindowSizeMsg struct {
	Width  int
	Height int
}