prompts

type ANSIRenderer struct {
	// Theme is immutable style/marker configuration; zero resolves to DefaultTheme.
	Theme Theme
}

type Accessibility struct {
	// Label is caller-localized raw display text, sanitized by owned rendering.
	Label string
	// Description is optional raw explanatory text with no universal byte ceiling.
	Description string
	// TextualHint adds localized linear navigation guidance independent of color.
	TextualHint string
}

type AutoRules struct {
	// RequireInputTerminal requires input-terminal evidence only in AutoDetect mode.
	RequireInputTerminal bool
	// RequireOutputTerminal requires output-terminal evidence only in AutoDetect mode.
	RequireOutputTerminal bool
}

type CancelBehavior uint8

type Capabilities struct {
	// InputTerminal reports explicit input-terminal evidence, independent of authority.
	InputTerminal bool
	// OutputTerminal reports explicit output-terminal evidence, independent of
	// authority.
	OutputTerminal bool
	// Width is initial output width; zero disables owned-renderer wrapping.
	Width int
	// Height controls selection pagination, not rendered-output bytes.
	Height int
	// Color selects output profile; zero is plain.
	Color ColorProfile
	// CursorMovement is metadata; owned rendering is linear, not cursor-updating.
	CursorMovement bool
	// Hyperlinks permits owned OSC 8 output with ANSIRenderer.
	Hyperlinks bool
	// Animation permits caller-selected spinner frames, not a timer or scheduler.
	Animation bool
	// Unicode permits native Unicode; false uses visible ASCII escapes.
	Unicode bool
}

type Clock interface {
	// Now returns implementation time; callers choose its authority and concurrency.
	Now() time.Time
	// NewTimer creates an owned timer for caller stop/cleanup.
	NewTimer(time.Duration) Timer
	// NewTicker creates an owned ticker for caller stop/cleanup.
	NewTicker(time.Duration) Ticker
}

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

type ColorProfile uint8

type ConfirmConfig struct {
	// ID, Label, Description, Placeholder, Hint, Help identify and describe the prompt;
	// ID/Label are required, other text is optional and sanitized at owned presentation
	// boundaries.
	ID, Label, Description, Placeholder, Hint, Help string
	// Default, Fallback distinguish present typed values from omission; execution
	// follows the selected behavior and caller authority.
	Default, Fallback Optional[bool]
	// Headless selects the noninteractive path; zero forbids headless execution.
	Headless HeadlessBehavior
	// Accessibility overrides localized label/description and adds textual navigation
	// guidance.
	Accessibility Accessibility
	// PreValidate, PostValidate are ordered callbacks before/after transformations;
	// slices are copied, callback state and context cooperation are not owned.
	PreValidate, PostValidate []Validator[bool]
	// Transform contains ordered synchronous transformations; context cooperation and
	// retained values remain caller-owned.
	Transform []Transformer[bool]
	// Retry bounds invalid interactive submissions; zero selects three attempts.
	Retry RetryPolicy
	// Cancel selects explicit cancel resolution; zero returns ErrCanceled.
	Cancel CancelBehavior
	// EndOfInput selects EOF/Ctrl-D resolution; zero returns ErrEndOfInput.
	EndOfInput EOFBehavior
	// Accept, Reject are copied true/false spellings; empty slices use defaults, values
	// trim/lowercase and must not overlap.
	Accept, Reject []string
}

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

type DateConfig struct {
	// ID, Label, Description, Placeholder, Hint, Help identify and describe the prompt;
	// ID/Label are required, other text is optional and sanitized at owned presentation
	// boundaries.
	ID, Label, Description, Placeholder, Hint, Help string
	// Default, Fallback distinguish present typed values from omission; execution
	// follows the selected behavior and caller authority.
	Default, Fallback Optional[Date]
	// Headless selects the noninteractive path; zero forbids headless execution.
	Headless HeadlessBehavior
	// Accessibility overrides localized label/description and adds textual navigation
	// guidance.
	Accessibility Accessibility
	// PreValidate, PostValidate are ordered callbacks before/after transformations;
	// slices are copied, callback state and context cooperation are not owned.
	PreValidate, PostValidate []Validator[Date]
	// Transform contains ordered synchronous transformations; context cooperation and
	// retained values remain caller-owned.
	Transform []Transformer[Date]
	// Retry bounds invalid interactive submissions; zero selects three attempts.
	Retry RetryPolicy
	// Cancel selects explicit cancel resolution; zero returns ErrCanceled.
	Cancel CancelBehavior
	// EndOfInput selects EOF/Ctrl-D resolution; zero returns ErrEndOfInput.
	EndOfInput EOFBehavior
}

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

type DecimalConfig struct {
	// ID, Label, Description, Placeholder, Hint, Help identify and describe the prompt;
	// ID/Label are required, other text is optional and sanitized at owned presentation
	// boundaries.
	ID, Label, Description, Placeholder, Hint, Help string
	// Default, Fallback distinguish present typed values from omission; execution
	// follows the selected behavior and caller authority.
	Default, Fallback Optional[Decimal]
	// Headless selects the noninteractive path; zero forbids headless execution.
	Headless HeadlessBehavior
	// Accessibility overrides localized label/description and adds textual navigation
	// guidance.
	Accessibility Accessibility
	// PreValidate, PostValidate are ordered callbacks before/after transformations;
	// slices are copied, callback state and context cooperation are not owned.
	PreValidate, PostValidate []Validator[Decimal]
	// Transform contains ordered synchronous transformations; context cooperation and
	// retained values remain caller-owned.
	Transform []Transformer[Decimal]
	// Retry bounds invalid interactive submissions; zero selects three attempts.
	Retry RetryPolicy
	// Cancel selects explicit cancel resolution; zero returns ErrCanceled.
	Cancel CancelBehavior
	// EndOfInput selects EOF/Ctrl-D resolution; zero returns ErrEndOfInput.
	EndOfInput EOFBehavior
}

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

type DecoderConfig struct {
	// MaxPasteBytes caps one retained bracketed paste; zero selects 1 MiB and must not
	// exceed MaxBufferBytes.
	MaxPasteBytes int
	// MaxBufferBytes caps buffered bytes plus each incoming chunk before copying; zero
	// selects 4 MiB.
	MaxBufferBytes int
	// ByteInput makes bracketed paste own SecretBytes rather than Text; callers must
	// destroy unused events.
	ByteInput bool
}

type Descriptor struct {
	// Kind identifies the semantic parser/editor family.
	Kind PromptKind
	// ID is the stable nonempty identity, not a display label or authentication proof.
	ID string
	// Label is caller-localized display text; owned rendering sanitizes terminal
	// controls.
	Label string
	// Description is optional caller-localized explanatory text, with no universal byte
	// cap.
	Description string
	// Placeholder is display-only empty-input guidance, not a submitted default.
	Placeholder string
	// Hint is optional display guidance, not validation or execution authority.
	Hint string
	// Help is optional caller-localized help rendered as semantic text.
	Help string
	// Retry bounds invalid submissions; zero normalizes to three attempts.
	Retry RetryPolicy
	// Cancel selects explicit cancel resolution; zero returns a cancellation error.
	Cancel CancelBehavior
	// EndOfInput selects EOF/Ctrl-D resolution; zero returns an end-of-input error.
	EndOfInput EOFBehavior
	// Secret selects display/error redaction; classification does not erase string
	// memory.
	Secret SecretClass
	// Headless selects the noninteractive path; zero forbids headless execution.
	Headless HeadlessBehavior
	// Accessibility overrides localized label/description and adds textual navigation
	// guidance.
	Accessibility Accessibility
}

type DurationConfig struct {
	// ID, Label, Description, Placeholder, Hint, Help identify and describe the prompt;
	// ID/Label are required, other text is optional and sanitized at owned presentation
	// boundaries.
	ID, Label, Description, Placeholder, Hint, Help string
	// Default, Fallback distinguish present typed values from omission; execution
	// follows the selected behavior and caller authority.
	Default, Fallback Optional[time.Duration]
	// Headless selects the noninteractive path; zero forbids headless execution.
	Headless HeadlessBehavior
	// Accessibility overrides localized label/description and adds textual navigation
	// guidance.
	Accessibility Accessibility
	// PreValidate, PostValidate are ordered callbacks before/after transformations;
	// slices are copied, callback state and context cooperation are not owned.
	PreValidate, PostValidate []Validator[time.Duration]
	// Transform contains ordered synchronous transformations; context cooperation and
	// retained values remain caller-owned.
	Transform []Transformer[time.Duration]
	// Retry bounds invalid interactive submissions; zero selects three attempts.
	Retry RetryPolicy
	// Cancel selects explicit cancel resolution; zero returns ErrCanceled.
	Cancel CancelBehavior
	// EndOfInput selects EOF/Ctrl-D resolution; zero returns ErrEndOfInput.
	EndOfInput EOFBehavior
}

type DynamicOptions[T any] struct {
	// contains filtered or unexported fields
}

type DynamicOptionsConfig[T any] struct {
	// Clock is borrowed; Now runs under session locks and must be prompt and
	// non-reentrant.
	Clock Clock
	// Provider is called synchronously outside session locks; cancellation and shallow
	// value ownership remain caller-owned.
	Provider OptionProvider[T]
	// Debounce is a nonnegative minimum delay checked against Clock; zero is immediate.
	Debounce time.Duration
	// MaxOptions caps admitted provider results after the call; zero selects 10000, not
	// a provider allocation budget.
	MaxOptions int
	// MaxQueryRunes caps validated query rune count; zero selects 256.
	MaxQueryRunes int
}

type EOFBehavior uint8

type Error struct {
	// Kind is stable classification; manually supplied kinds must not carry secrets or
	// terminal controls.
	Kind ErrorKind
	// Operation is context sanitized during Error formatting, not a secret-redaction
	// boundary.
	Operation string
	// PromptID is stable prompt context sanitized by Error formatting.
	PromptID string
	// Cause is omitted from default Error text but remains accessible through Unwrap.
	Cause error
}

type ErrorKind string

type EventKind uint8

type EventSource interface {
	// Next returns one semantic event or context/read error; implementations must honor
	// cancellation and transfer byte-payload ownership.
	Next(context.Context) (InputEvent, error)
}

type Execution struct {
	// Input is for explicit adapter composition; core Run consumes Events, not this
	// reader.
	Input io.Reader
	// Output is a borrowed synchronous writer; context checks cannot interrupt a
	// blocking Write.
	Output io.Writer
	// Error is supplied diagnostic output for caller composition; core Run does not
	// write it.
	Error io.Writer
	// Capabilities supplies initial terminal evidence, not interaction permission.
	Capabilities Capabilities
	// Policy supplies caller authority for interaction, defaults and unlimited retries.
	Policy InteractionPolicy
	// Clock is an explicit timing seam for caller composition; core prompts add no
	// timers.
	Clock Clock
	// Dependencies is passed through to callbacks without copying or container
	// ownership.
	Dependencies any
	// Events is borrowed; implementations must honor cancellation without a hidden core
	// worker.
	Events EventSource
	// Terminal is acquired per interactive prompt; ordinary exits attempt restore/release.
	// Cleanup must return promptly rather than block or panic.
	Terminal TerminalController
	// Renderer is synchronous and borrowed; nil selects the capability-driven owned
	// renderer.
	Renderer Renderer
	// Theme is immutable default-renderer configuration; zero resolves to DefaultTheme.
	Theme Theme
	// Limits bounds interactive text/paste; nonpositive values select defaults, not
	// explicit Parse budgets.
	Limits InputLimits
	// Keys is the immutable local remap; zero uses default semantic bindings.
	Keys KeyMap
}

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

type FormConfig struct {
	// ID is the stable nonempty identity, independent of display text.
	ID string
	// Fields is copied in declaration order; fields need unique nonempty identities and
	// come from AsField/When.
	Fields []FormField
	// Validate is copied ordered cross-field validation after enabled fields; callbacks
	// are panic-contained.
	Validate []FormValidator
	// Dependencies is fallback for cross-field validators only, overridden by non-nil
	// Execution.Dependencies.
	Dependencies any
}

type FormField interface {
	// contains filtered or unexported methods
}

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

type FormValidator func(context.Context, FormResult, ValidationContext) error

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

type HeadlessBehavior uint8

type InputEvent struct {
	// Kind selects which event payload fields execution interprets.
	Kind EventKind
	// Key is the semantic key interpreted for EventKey, subject to execution remapping.
	Key Key
	// Rune carries KeyRune input; direct field access bypasses formatting redaction.
	Rune rune
	// Text is borrowed immutable paste text; clearing references cannot erase it.
	Text string
	// Bytes is a shared paste wrapper; transfer or explicit Destroy determines its
	// lifetime.
	Bytes *SecretBytes
	// Width, Height are caller resize dimensions; negative interactive dimensions are
	// rejected.
	Width, Height int
	// Capabilities is the full replacement snapshot for EventCapabilities.
	Capabilities Capabilities
}

type InputLimits struct {
	// MaxPasteBytes caps an interactive paste; nonpositive values select 1 MiB.
	MaxPasteBytes int
	// MaxInputBytes caps retained interactive editor bytes; nonpositive values select 4
	// MiB.
	MaxInputBytes int
}

type IntegerConfig struct {
	// ID, Label, Description, Placeholder, Hint, Help identify and describe the prompt;
	// ID/Label are required, other text is optional and sanitized at owned presentation
	// boundaries.
	ID, Label, Description, Placeholder, Hint, Help string
	// Default, Fallback distinguish present typed values from omission; execution
	// follows the selected behavior and caller authority.
	Default, Fallback Optional[int64]
	// Headless selects the noninteractive path; zero forbids headless execution.
	Headless HeadlessBehavior
	// Accessibility overrides localized label/description and adds textual navigation
	// guidance.
	Accessibility Accessibility
	// PreValidate, PostValidate are ordered callbacks before/after transformations;
	// slices are copied, callback state and context cooperation are not owned.
	PreValidate, PostValidate []Validator[int64]
	// Transform contains ordered synchronous transformations; context cooperation and
	// retained values remain caller-owned.
	Transform []Transformer[int64]
	// Retry bounds invalid interactive submissions; zero selects three attempts.
	Retry RetryPolicy
	// Cancel selects explicit cancel resolution; zero returns ErrCanceled.
	Cancel CancelBehavior
	// EndOfInput selects EOF/Ctrl-D resolution; zero returns ErrEndOfInput.
	EndOfInput EOFBehavior
}

type InteractionMode uint8

type InteractionPolicy struct {
	// Mode selects interaction policy; zero requires both terminal capabilities and
	// permission.
	Mode InteractionMode
	// PermitInteraction is explicit caller authorization; detection alone never grants
	// it.
	PermitInteraction bool
	// PermitDefaults permits HeadlessUseDefault; explicit cancel/EOF defaults use their
	// own configured behavior.
	PermitDefaults bool
	// PermitUnlimitedRetries permits explicitly unlimited interactive retry definitions.
	PermitUnlimitedRetries bool
	// Auto selects capability prerequisites only for AutoDetect.
	Auto AutoRules
}

type Key uint8

type KeyBinding struct {
	// Input is a non-rune physical semantic key; duplicate bindings are rejected.
	Input Key
	// Meaning is an existing non-rune meaning whose prior shortcuts become inert.
	Meaning Key
}

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

type KeyValue struct {
	// Key, Value are ordered summary label/value text; Key is required and owned
	// rendering sanitizes both.
	Key, Value string
}

type Message struct {
	// Kind selects a fixed role; values beyond MessageSuccess are rejected.
	Kind MessageKind
	// Title, Body are localized message text; Title is required and Body may contain
	// line-separated text.
	Title, Body string
}

type MessageKind uint8

type MultiSelectConfig[T any] struct {
	// ID, Label, Description, Placeholder, Hint, Help identify and describe the prompt;
	// ID/Label are required, other text is optional and sanitized at owned presentation
	// boundaries.
	ID, Label, Description, Placeholder, Hint, Help string
	// DefaultIDs, FallbackIDs select unique enabled identities resolved in declaration
	// order; generic option values remain shallow.
	DefaultIDs, FallbackIDs Optional[[]string]
	// Headless selects the noninteractive path; zero forbids headless execution.
	Headless HeadlessBehavior
	// Accessibility overrides localized label/description and adds textual navigation
	// guidance.
	Accessibility Accessibility
	// PreValidate, PostValidate are ordered callbacks before/after transformations;
	// slices are copied, callback state and context cooperation are not owned.
	PreValidate, PostValidate []Validator[[]T]
	// Transform contains ordered synchronous transformations; context cooperation and
	// retained values remain caller-owned.
	Transform []Transformer[[]T]
	// Retry bounds invalid interactive submissions; zero selects three attempts.
	Retry RetryPolicy
	// Cancel selects explicit cancel resolution; zero returns ErrCanceled.
	Cancel CancelBehavior
	// EndOfInput selects EOF/Ctrl-D resolution; zero returns ErrEndOfInput.
	EndOfInput EOFBehavior
	// Options is copied as a slice; unique nonempty identities are required, generic
	// values stay shallow.
	Options []Option[T]
	// InitialIDs are copied initial selections checked against enabled identities and
	// bounds.
	InitialIDs []string
	// Min, Max bound selected cardinality; zero Max means all options and Min must be
	// nonnegative.
	Min, Max int
	// MaxOptions caps static option count; zero selects 10000.
	MaxOptions int
}

type MultilineConfig struct {
	// ID, Label, Description, Placeholder, Hint, Help identify and describe the prompt;
	// ID/Label are required, other text is optional and sanitized at owned presentation
	// boundaries.
	ID, Label, Description, Placeholder, Hint, Help string
	// Default, Fallback distinguish present typed values from omission; execution
	// follows the selected behavior and caller authority.
	Default, Fallback Optional[string]
	// Headless selects the noninteractive path; zero forbids headless execution.
	Headless HeadlessBehavior
	// Accessibility overrides localized label/description and adds textual navigation
	// guidance.
	Accessibility Accessibility
	// PreValidate, PostValidate are ordered callbacks before/after transformations;
	// slices are copied, callback state and context cooperation are not owned.
	PreValidate, PostValidate []Validator[string]
	// Transform contains ordered synchronous transformations; context cooperation and
	// retained values remain caller-owned.
	Transform []Transformer[string]
	// Retry bounds invalid interactive submissions; zero selects three attempts.
	Retry RetryPolicy
	// Cancel selects explicit cancel resolution; zero returns ErrCanceled.
	Cancel CancelBehavior
	// EndOfInput selects EOF/Ctrl-D resolution; zero returns ErrEndOfInput.
	EndOfInput EOFBehavior
	// Secret selects display/error redaction, not string-memory erasure.
	Secret SecretClass
}

type Option[T any] struct {
	// contains filtered or unexported fields
}

type OptionConfig[T any] struct {
	// ID is the stable nonempty identity, independent of display text.
	ID string
	// Label is caller-localized raw display text, sanitized by owned rendering.
	Label string
	// Description is optional raw explanatory text with no universal byte ceiling.
	Description string
	// Group is raw display grouping, not a sorting or identity key.
	Group string
	// Value is stored by ordinary assignment; referenced maps/slices/pointers are not
	// deeply copied.
	Value T
	// Disabled keeps an option visible but unavailable for selection/default/fallback.
	Disabled bool
}

type OptionProvider[T any] func(context.Context, string) ([]Option[T], error)

type Optional[T any] struct {
	// contains filtered or unexported fields
}

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

type PathConfig struct {
	// ID, Label, Description, Placeholder, Hint, Help identify and describe the prompt;
	// ID/Label are required, other text is optional and sanitized at owned presentation
	// boundaries.
	ID, Label, Description, Placeholder, Hint, Help string
	// Default, Fallback distinguish present typed values from omission; execution
	// follows the selected behavior and caller authority.
	Default, Fallback Optional[Path]
	// Headless selects the noninteractive path; zero forbids headless execution.
	Headless HeadlessBehavior
	// Accessibility overrides localized label/description and adds textual navigation
	// guidance.
	Accessibility Accessibility
	// PreValidate, PostValidate are ordered callbacks before/after transformations;
	// slices are copied, callback state and context cooperation are not owned.
	PreValidate, PostValidate []Validator[Path]
	// Transform contains ordered synchronous transformations; context cooperation and
	// retained values remain caller-owned.
	Transform []Transformer[Path]
	// Retry bounds invalid interactive submissions; zero selects three attempts.
	Retry RetryPolicy
	// Cancel selects explicit cancel resolution; zero returns ErrCanceled.
	Cancel CancelBehavior
	// EndOfInput selects EOF/Ctrl-D resolution; zero returns ErrEndOfInput.
	EndOfInput EOFBehavior
	// Kind is filesystem intent only; parsing does not access the filesystem.
	Kind PathKind
}

type PathKind uint8

type PlainRenderer struct {
	// Theme is immutable style/marker configuration; zero resolves to DefaultTheme.
	Theme Theme
}

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

type ProgressConfig struct {
	// ID, Label are required stable identity and caller-localized display text.
	ID, Label string
	// Total is nonnegative; zero is indeterminate, positive totals bound current
	// updates.
	Total int64
	// AllowRegression permits lower Update values and resets timing baselines; Increment
	// still rejects negative deltas.
	AllowRegression bool
	// Clock is optional; Now runs under the progress mutex and must be prompt and
	// non-reentrant.
	Clock Clock
}

type ProgressSnapshot struct {
	// ID, Label, Message are copied identity, label and latest raw progress message.
	ID, Label, Message string
	// Current, Total are latest progress and configured total; zero Total means
	// indeterminate.
	Current, Total int64
	// State is latest lifecycle state; first terminal transition wins.
	State ProgressState
	// Elapsed is time since the current measurement baseline, not constructor wall time.
	Elapsed time.Duration
	// RatePerSecond is present only for positive elapsed time and progress delta.
	RatePerSecond Optional[float64]
	// EstimatedRemaining is optional bounded ETA when a determinate total has a usable
	// rate.
	EstimatedRemaining Optional[time.Duration]
}

type ProgressState uint8

type Prompt[T any] struct {
	// contains filtered or unexported fields
}

type PromptKind string

type QueryGeneration uint64

type RenderOptions struct {
	// Width is a nonnegative grapheme-cell wrapping target; zero disables wrapping.
	Width int
	// Color must be a valid profile even when rendering plain text.
	Color ColorProfile
	// ASCIIOnly renders non-ASCII runes as visible escapes after sanitization.
	ASCIIOnly bool
	// Hyperlinks permits owned OSC 8 in ANSI mode; plain mode prints targets.
	Hyperlinks bool
}

type Renderer interface {
	// Render converts a frame synchronously under explicit capabilities; implementations
	// own blocking and sanitization.
	Render(Frame, RenderOptions) (string, error)
}

type RetryPolicy struct {
	// MaxAttempts counts invalid interactive submissions; zero selects three unless
	// Unlimited is true.
	MaxAttempts uint
	// Unlimited requires zero MaxAttempts and explicit interactive
	// PermitUnlimitedRetries authority.
	Unlimited bool
}

type Role string

type SearchPolicy struct {
	// MaxOptions caps admitted options; all-zero SearchPolicy selects 10000.
	MaxOptions int
	// MaxResults caps returned ranked matches; all-zero SearchPolicy selects 50.
	MaxResults int
	// MaxQueryRunes caps query runes before normalization; all-zero SearchPolicy selects
	// 256.
	MaxQueryRunes int
}

type SearchSelectConfig[T any] struct {
	// Select supplies copied static options and single-selection behavior.
	Select SelectConfig[T]
	// Search supplies ranking bounds; partially zero policies are rejected.
	Search SearchPolicy
}

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

type SecretBytesConfig struct {
	// ID, Label, Description, Placeholder, Hint, Help identify and describe the prompt;
	// ID/Label are required, other text is optional and sanitized at owned presentation
	// boundaries.
	ID, Label, Description, Placeholder, Hint, Help string
	// Default, Fallback distinguish present typed values from omission; execution
	// follows the selected behavior and caller authority.
	Default, Fallback Optional[*SecretBytes]
	// Headless selects the noninteractive path; zero forbids headless execution.
	Headless HeadlessBehavior
	// Accessibility overrides localized label/description and adds textual navigation
	// guidance.
	Accessibility Accessibility
	// PreValidate, PostValidate are ordered callbacks before/after transformations;
	// slices are copied, callback state and context cooperation are not owned.
	PreValidate, PostValidate []Validator[*SecretBytes]
	// Transform contains ordered synchronous transformations; context cooperation and
	// retained values remain caller-owned.
	Transform []Transformer[*SecretBytes]
	// Retry bounds invalid interactive submissions; zero selects three attempts.
	Retry RetryPolicy
	// Cancel selects explicit cancel resolution; zero returns ErrCanceled.
	Cancel CancelBehavior
	// EndOfInput selects EOF/Ctrl-D resolution; zero returns ErrEndOfInput.
	EndOfInput EOFBehavior
	// Class must classify Password, Token or Other; secret constructors reject zero.
	Class SecretClass
}

type SecretClass uint8

type SecretConfig struct {
	// ID, Label, Description, Placeholder, Hint, Help identify and describe the prompt;
	// ID/Label are required, other text is optional and sanitized at owned presentation
	// boundaries.
	ID, Label, Description, Placeholder, Hint, Help string
	// Default, Fallback distinguish present typed values from omission; execution
	// follows the selected behavior and caller authority.
	Default, Fallback Optional[SecretValue]
	// Headless selects the noninteractive path; zero forbids headless execution.
	Headless HeadlessBehavior
	// Accessibility overrides localized label/description and adds textual navigation
	// guidance.
	Accessibility Accessibility
	// PreValidate, PostValidate are ordered callbacks before/after transformations;
	// slices are copied, callback state and context cooperation are not owned.
	PreValidate, PostValidate []Validator[SecretValue]
	// Transform contains ordered synchronous transformations; context cooperation and
	// retained values remain caller-owned.
	Transform []Transformer[SecretValue]
	// Retry bounds invalid interactive submissions; zero selects three attempts.
	Retry RetryPolicy
	// Cancel selects explicit cancel resolution; zero returns ErrCanceled.
	Cancel CancelBehavior
	// EndOfInput selects EOF/Ctrl-D resolution; zero returns ErrEndOfInput.
	EndOfInput EOFBehavior
	// Class must classify Password, Token or Other; secret constructors reject zero.
	Class SecretClass
}

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

type Segment struct {
	// Role selects semantic style/marker; unknown roles remain unstyled.
	Role Role
	// Content is raw caller text sanitized during owned rendering, without a universal
	// size cap.
	Content string
	// contains filtered or unexported fields
}

type SelectConfig[T any] struct {
	// ID, Label, Description, Placeholder, Hint, Help identify and describe the prompt;
	// ID/Label are required, other text is optional and sanitized at owned presentation
	// boundaries.
	ID, Label, Description, Placeholder, Hint, Help string
	// DefaultID, FallbackID select enabled option identities; omission does not
	// implicitly choose an option.
	DefaultID, FallbackID Optional[string]
	// Headless selects the noninteractive path; zero forbids headless execution.
	Headless HeadlessBehavior
	// Accessibility overrides localized label/description and adds textual navigation
	// guidance.
	Accessibility Accessibility
	// PreValidate, PostValidate are ordered callbacks before/after transformations;
	// slices are copied, callback state and context cooperation are not owned.
	PreValidate, PostValidate []Validator[T]
	// Transform contains ordered synchronous transformations; context cooperation and
	// retained values remain caller-owned.
	Transform []Transformer[T]
	// Retry bounds invalid interactive submissions; zero selects three attempts.
	Retry RetryPolicy
	// Cancel selects explicit cancel resolution; zero returns ErrCanceled.
	Cancel CancelBehavior
	// EndOfInput selects EOF/Ctrl-D resolution; zero returns ErrEndOfInput.
	EndOfInput EOFBehavior
	// Options is copied as a slice; unique nonempty identities are required, generic
	// values stay shallow.
	Options []Option[T]
	// InitialID is optional enabled initial focus/selection, not headless fallback.
	InitialID string
	// MaxOptions caps static option count; zero selects 10000.
	MaxOptions int
}

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

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

type SpinnerConfig struct {
	// ID, Label are required stable identity and caller-localized display text.
	ID, Label string
	// Frames are copied; empty selects four ASCII frames, advances remain caller-driven.
	Frames []string
}

type SpinnerSnapshot struct {
	ProgressSnapshot
	// Frame is the current spinner glyph; rendering can omit it without animation
	// capability.
	Frame string
}

type StatusEntry struct {
	// Kind selects fixed status role; values beyond StatusSuccess are rejected.
	Kind StatusKind
	// Text is raw caller message text; capacity bounds entries, not their bytes.
	Text string
}

type StatusKind uint8

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

type Style struct {
	// Foreground is semantic color; zero leaves the terminal default.
	Foreground Color
	// Bold requests bold only under ANSI styling capability.
	Bold bool
	// Underline requests underline only under ANSI styling capability.
	Underline bool
	// Dim requests dim only under ANSI styling capability.
	Dim bool
}

type Table struct {
	// Headers are borrowed required table labels; callers must not mutate during
	// rendering.
	Headers []string
	// Rows are borrowed rectangular cells; callers bound text bytes.
	Rows [][]string
	// MaxRows, MaxColumns bound table counts; zero selects 1000 rows and 50 columns, not
	// per-cell bytes.
	MaxRows, MaxColumns int
}

type Task struct {
	// Progress is the group-owned state handle; callers must not replace it or copy its mutex.
	*Progress
	// contains filtered or unexported fields
}

type TaskConfig struct {
	// ID, Label are required stable identity and caller-localized display text.
	ID, Label string
	// ParentID is optional parent identity; Add requires the parent to already exist.
	ParentID string
	// Total is nonnegative; zero is indeterminate progress.
	Total int64
	// AllowRegression permits lower progress updates, not negative Increment values.
	AllowRegression bool
}

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

type TaskGroupConfig struct {
	// ID, Label are required stable identity and caller-localized display text.
	ID, Label string
	// MaxTasks caps group membership; zero selects 100, not worker count or text bytes.
	MaxTasks int
}

type TaskSnapshot struct {
	ProgressSnapshot
	// ParentID is optional parent identity; Add requires the parent to already exist.
	ParentID string
}

type TerminalController interface {
	// Acquire acquires explicit state; success requires a later Release.
	Acquire(context.Context) error
	// SetEcho configures owned terminal echo; implementations must not disclose secret
	// input.
	SetEcho(bool) error
	// Release attempts restoration; failures must remain visible.
	Release() error
}

type TextConfig struct {
	// ID is the stable nonempty identity, independent of display text.
	ID string
	// Label is caller-localized raw display text, sanitized by owned rendering.
	Label string
	// Description is optional raw explanatory text with no universal byte ceiling.
	Description string
	// Placeholder is empty-input display guidance, not a submitted default.
	Placeholder string
	// Hint is optional semantic guidance, not validation authority.
	Hint string
	// Help is optional localized extended guidance.
	Help string
	// Default distinguishes a present typed default from omission; Some preserves zero
	// values.
	Default Optional[string]
	// Fallback distinguishes a present typed fallback from omission.
	Fallback Optional[string]
	// Headless selects the noninteractive path; zero forbids headless execution.
	Headless HeadlessBehavior
	// Accessibility overrides localized label/description and adds textual navigation
	// guidance.
	Accessibility Accessibility
	// PreValidate contains ordered validators for the parsed value; constructors copy
	// callback slices but not callback state.
	PreValidate []Validator[string]
	// Transform contains ordered synchronous transformations; context cooperation and
	// retained values remain caller-owned.
	Transform []Transformer[string]
	// PostValidate contains ordered validators for the transformed value; constructors
	// copy callback slices but not callback state.
	PostValidate []Validator[string]
	// Retry bounds invalid interactive submissions; zero selects three attempts.
	Retry RetryPolicy
	// Cancel selects explicit cancel resolution; zero returns ErrCanceled.
	Cancel CancelBehavior
	// EndOfInput selects EOF/Ctrl-D resolution; zero returns ErrEndOfInput.
	EndOfInput EOFBehavior
	// Secret selects display/error redaction, not string-memory erasure.
	Secret SecretClass
}

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

type Ticker interface {
	// C returns the owned event channel; Stop need not close it.
	C() <-chan time.Time
	// Stop prevents future tick generation; already buffered values can remain
	// and the channel need not close.
	Stop()
}

type TimeConfig struct {
	// ID, Label, Description, Placeholder, Hint, Help identify and describe the prompt;
	// ID/Label are required, other text is optional and sanitized at owned presentation
	// boundaries.
	ID, Label, Description, Placeholder, Hint, Help string
	// Default, Fallback distinguish present typed values from omission; execution
	// follows the selected behavior and caller authority.
	Default, Fallback Optional[TimeOfDay]
	// Headless selects the noninteractive path; zero forbids headless execution.
	Headless HeadlessBehavior
	// Accessibility overrides localized label/description and adds textual navigation
	// guidance.
	Accessibility Accessibility
	// PreValidate, PostValidate are ordered callbacks before/after transformations;
	// slices are copied, callback state and context cooperation are not owned.
	PreValidate, PostValidate []Validator[TimeOfDay]
	// Transform contains ordered synchronous transformations; context cooperation and
	// retained values remain caller-owned.
	Transform []Transformer[TimeOfDay]
	// Retry bounds invalid interactive submissions; zero selects three attempts.
	Retry RetryPolicy
	// Cancel selects explicit cancel resolution; zero returns ErrCanceled.
	Cancel CancelBehavior
	// EndOfInput selects EOF/Ctrl-D resolution; zero returns ErrEndOfInput.
	EndOfInput EOFBehavior
}

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

type Timer interface {
	// C returns the owned event channel; Stop need not close it.
	C() <-chan time.Time
	// Stop reports whether an active event was stopped; an already buffered value
	// can remain and the channel need not close.
	Stop() bool
}

type Transformer[T any] func(context.Context, T, ValidationContext) (T, error)

type ValidationContext struct {
	// Dependencies is the exact borrowed callback dependency value; callers own
	// synchronization.
	Dependencies any
}

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

type Validator[T any] func(context.Context, T, ValidationContext) error

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

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