ui

type ActionFunc func(EventContext, Intent) EventResult

type Actions struct {
	// Bindings maps intent types to handlers.
	Bindings map[IntentType]ActionFunc
	// Child is the subtree that can invoke these actions.
	Child Widget
}

type ActivateIntent struct{}

type Align struct {
	// Alignment controls where the child is placed.
	Alignment Alignment
	// Child is laid out loosely within the available space.
	Child Widget
}

type Alignment struct{ X, Y int }

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

type AnimationOptions struct {
	// Duration is the time from progress 0 to progress 1.
	Duration time.Duration
	// Curve maps raw progress to the value returned by AnimationController.Value.
	Curve Curve
}

type AnimationStatus int

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

type AttributeMask = vaxis.AttributeMask

type Axis int

type Backend interface {
	Events() <-chan Event
	Size() Size
	Render(*Painter) error
	Dispatch(func())
	SetMouseShape(MouseShape)
	Close() error
}

type BaseColors struct {
	Black   Color
	Red     Color
	Green   Color
	Yellow  Color
	Blue    Color
	Magenta Color
	Cyan    Color
	White   Color
}

type BoolChangedCallback func(EventContext, bool)

type Border struct {
	// Style is used to draw border cells.
	Style Style
	// Top, Right, Bottom, and Left enable individual border edges.
	Top, Right, Bottom, Left bool
	// Chars customizes the border drawing characters.
	Chars BorderChars
}

type BorderChars struct {
	// Horizontal and Vertical draw straight border edges.
	Horizontal, Vertical Character
	// TopLeft and TopRight draw the top corners.
	TopLeft, TopRight Character
	// BottomLeft and BottomRight draw the bottom corners.
	BottomLeft, BottomRight Character
}

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

type Button struct {
	// Label is the text shown inside the button.
	Label string
	// OnPressed is called when the button is activated.
	OnPressed VoidCallback
	// Padding overrides the default button padding when non-zero.
	Padding Insets
	// MinWidth overrides the default button minimum width when greater than zero.
	MinWidth int
}

type ButtonTheme struct {
	Normal         Style
	Focused        Style
	Hovered        Style
	FocusedHovered Style
	Pressed        Style
	Padding        Insets
	MinWidth       int
	Mouse          MouseShape
	FocusLeft      Character
	FocusRight     Character
}

type Cell = vaxis.Cell

type Character = vaxis.Character

type Checkbox struct {
	// Checked controls whether the checkbox is painted as selected.
	Checked bool
	// Disabled prevents focus, hover, and activation when true.
	Disabled bool
	// Label is painted after the checkbox when non-empty.
	Label string
	// OnChanged is called with the next checked value when the checkbox is activated.
	OnChanged BoolChangedCallback
}

type ChildOffsetProvider interface {
	ChildOffset(RenderObject) Offset
}

type ClickAffordance int

type Color = vaxis.Color

type ColorScale struct {
	Tone50  Color
	Tone100 Color
	Tone200 Color
	Tone300 Color
	Tone400 Color
	Tone500 Color
	Tone600 Color
	Tone700 Color
	Tone800 Color
	Tone900 Color
	Tone950 Color
}

type ColorThemeMode = vaxis.ColorThemeMode

type ColorThemeUpdate = vaxis.ColorThemeUpdate

type CommandPalette struct {
	// Items are filtered, displayed, and activated by the palette.
	Items []CommandPaletteItem
	// Filter filters and ranks Items for the current query. When nil,
	// DefaultCommandPaletteFilter is used.
	Filter CommandPaletteFilter
	// Placeholder is shown in the search field when the query is empty.
	Placeholder string
	// EmptyText is shown when no items match the query.
	EmptyText string
	// Width is the panel content width when greater than zero.
	Width int
	// MaxVisibleRows limits visible result rows before scrolling.
	MaxVisibleRows int
	// OnDismiss is called when Escape is pressed.
	OnDismiss VoidCallback
	// OnSelected is called after the selected item's OnSelected callback.
	OnSelected CommandPaletteSelectedCallback
}

type CommandPaletteFilter func(query string, items []CommandPaletteItem) []CommandPaletteItem

type CommandPaletteItem struct {
	// Title is the primary row text.
	Title string
	// Description is optional secondary row text.
	Description string
	// Aliases are additional strings matched by the default fuzzy filter.
	Aliases []string
	// Leading is painted before the title content when non-nil.
	Leading Widget
	// Trailing is painted at the end of the row when non-nil.
	Trailing Widget
	// Disabled prevents activation when true.
	Disabled bool
	// OnSelected is called when this item is activated.
	OnSelected VoidCallback
}

type CommandPaletteSelectedCallback func(EventContext, CommandPaletteItem)

type ConstrainedBox struct {
	// Constraints are enforced inside the parent constraints.
	Constraints Constraints
	// Child is laid out with the combined constraints.
	Child Widget
}

type Constraints struct {
	// MinWidth is the smallest width a render object may choose.
	MinWidth int
	// MaxWidth is the largest width a render object may choose, or Unbounded.
	MaxWidth int
	// MinHeight is the smallest height a render object may choose.
	MinHeight int
	// MaxHeight is the largest height a render object may choose, or Unbounded.
	MaxHeight int
}

type CopySelectionTextIntent struct {
	// OnCopied is called with the copied text after a non-empty selection is
	// placed on the clipboard.
	OnCopied func(string)
}

type CrossAxisAlignment int

type Cursor struct {
	// Col and Row locate the cursor relative to the child origin.
	Col, Row int
	// Shape is the terminal cursor style to request.
	Shape CursorStyle
	// Hidden suppresses the cursor while still painting the child.
	Hidden bool
	// Child is painted before the cursor is requested.
	Child Widget
}

type CursorState struct {
	Col   int
	Row   int
	Shape CursorStyle
}

type CursorStyle = vaxis.CursorStyle

type Curve func(float64) float64

type CustomScrollView struct {
	// Controller can be used to inspect and change scroll position
	// programmatically after this view is mounted.
	Controller *ScrollController
	// FollowOutput keeps the viewport at the end when it is already at the end
	// before content grows. If the user scrolls away from the end, new content
	// does not move the viewport until it is scrolled back to the end.
	FollowOutput bool
	// Slivers are laid out vertically in order.
	Slivers []Widget
}

type DebugCursor struct {
	Col   int         `json:"col"`
	Row   int         `json:"row"`
	Shape CursorStyle `json:"shape"`
}

type DebugFocusTarget struct {
	ID      string `json:"id"`
	Index   int    `json:"index"`
	Label   string `json:"label,omitempty"`
	Focused bool   `json:"focused,omitempty"`
}

type DebugNode struct {
	ID           string             `json:"id"`
	Widget       string             `json:"widget"`
	Element      string             `json:"element"`
	State        string             `json:"state,omitempty"`
	Render       string             `json:"render,omitempty"`
	Size         *DebugSize         `json:"size,omitempty"`
	Offset       *DebugOffset       `json:"offset,omitempty"`
	Dirty        bool               `json:"dirty,omitempty"`
	NeedsLayout  bool               `json:"needsLayout,omitempty"`
	NeedsPaint   bool               `json:"needsPaint,omitempty"`
	ParentData   string             `json:"parentData,omitempty"`
	FocusTargets []DebugFocusTarget `json:"focusTargets,omitempty"`
	Children     []DebugNode        `json:"children,omitempty"`
}

type DebugOffset struct {
	X int `json:"x"`
	Y int `json:"y"`
}

type DebugProfileSample struct {
	Count  int     `json:"count"`
	LastMS float64 `json:"last_ms"`
	P95MS  float64 `json:"p95_ms"`
	P99MS  float64 `json:"p99_ms"`
}

type DebugProfileSnapshot struct {
	Window int                `json:"window"`
	Key    DebugProfileSample `json:"key"`
	Mouse  DebugProfileSample `json:"mouse"`
	Build  DebugProfileSample `json:"build"`
	Layout DebugProfileSample `json:"layout"`
	Paint  DebugProfileSample `json:"paint"`
	Render DebugProfileSample `json:"render"`
	Frame  DebugProfileSample `json:"frame"`
}

type DebugRenderedCell struct {
	Col             int            `json:"col"`
	Row             int            `json:"row"`
	Grapheme        string         `json:"grapheme,omitempty"`
	Width           int            `json:"width,omitempty"`
	Foreground      Color          `json:"foreground,omitempty"`
	Background      Color          `json:"background,omitempty"`
	UnderlineColor  Color          `json:"underlineColor,omitempty"`
	UnderlineStyle  UnderlineStyle `json:"underlineStyle,omitempty"`
	Attribute       AttributeMask  `json:"attribute,omitempty"`
	Hyperlink       string         `json:"hyperlink,omitempty"`
	HyperlinkParams string         `json:"hyperlinkParams,omitempty"`
}

type DebugRenderedSnapshot struct {
	Size   DebugSize           `json:"size"`
	Cursor *DebugCursor        `json:"cursor,omitempty"`
	Cells  []DebugRenderedCell `json:"cells"`
}

type DebugSize struct {
	Width  int `json:"width"`
	Height int `json:"height"`
}

type DebugSnapshot struct {
	Size       DebugSize          `json:"size"`
	Window     DebugWindow        `json:"window"`
	MouseShape MouseShape         `json:"mouseShape"`
	Focused    string             `json:"focused,omitempty"`
	Focusables []DebugFocusTarget `json:"focusables,omitempty"`
	Tree       *DebugNode         `json:"tree,omitempty"`
}

type DebugWindow struct {
	Cols   int `json:"cols"`
	Rows   int `json:"rows"`
	XPixel int `json:"xPixel,omitempty"`
	YPixel int `json:"yPixel,omitempty"`
}

type Decoration struct {
	// Style is used for the background fill.
	Style Style
	// Fill is the character used to fill the box; a space is used when zero.
	Fill Character
	// Border describes the optional border drawn over the fill.
	Border Border
}

type DefaultActions struct {
	// Bindings maps intent types to fallback handlers.
	Bindings map[IntentType]ActionFunc
	// Child is the subtree that can invoke these actions.
	Child Widget
}

type DeleteTextIntent struct {
	Direction TextDeleteDirection
	Unit      TextMotionUnit
}

type Dialog struct {
	// Title is painted at the top of the dialog when non-empty.
	Title string
	// Child is the main dialog content.
	Child Widget
	// Actions are laid out horizontally at the bottom-right.
	Actions []Widget
	// Width fixes the dialog width when greater than zero.
	Width int
	// OnDismiss is called when Escape is pressed while focus is inside the dialog.
	OnDismiss VoidCallback
	// DisableFocusReclaim prevents the dialog from moving focus back to its first
	// focusable child on every rebuild after the initial autofocus.
	DisableFocusReclaim bool
}

type DismissIntent struct{}

type Divider struct {
	// Axis controls the divider orientation.
	Axis Axis
	// Character overrides the line character.
	Character Character
	// Style overrides Theme foreground when non-zero fields are set.
	Style Style
}

type DryLayouter interface {
	DryLayout(LayoutContext, Constraints) Size
}

type Event = vaxis.Event

type EventCallback func(EventContext, Event) EventResult

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

type EventHandler interface {
	HandleEvent(EventContext, Event) EventResult
}

type EventPhase int

type EventResult int

type ExpandedWidget struct {
	// Flex is the share of remaining space assigned to the child.
	Flex int
	// Child is the wrapped child.
	Child Widget
}

type Flex struct {
	// Axis is the direction children are placed.
	Axis Axis
	// MainAxisSize controls whether the flex expands or shrinks on its main axis.
	MainAxisSize MainAxisSize
	// MainAxisAlignment controls how extra main-axis space is distributed.
	MainAxisAlignment MainAxisAlignment
	// CrossAxisAlignment controls child placement on the cross axis.
	CrossAxisAlignment CrossAxisAlignment
	// Children is the ordered list of children.
	Children []Widget
}

type FlexFit int

type FlexParentData struct {
	// Flex is the child's flex factor.
	Flex int
	// Fit controls whether the child must fill its flex allocation.
	Fit FlexFit
	// Offset is the child paint offset computed by renderFlex.
	Offset Offset
}

type FlexibleWidget struct {
	// Flex is the share of remaining space assigned to the child.
	Flex int
	// Fit controls whether the child must fill its flex allocation.
	Fit FlexFit
	// Child is the wrapped child.
	Child Widget
}

type FloatTween struct {
	// Begin is the value returned at progress 0.
	Begin float64
	// End is the value returned at progress 1.
	End float64
}

type FocusIn = vaxis.FocusIn

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

type FocusOptions struct {
	// SkipTraversal removes this target from Tab and Shift+Tab traversal while
	// still allowing it to request focus directly.
	SkipTraversal bool
}

type FocusOut = vaxis.FocusOut

type FocusScope struct {
	// Trap keeps Tab and Shift+Tab traversal inside Child while focus is inside
	// this scope.
	Trap bool
	// AutoFocus moves focus to the first descendant focus target after build
	// when focus is outside the scope.
	AutoFocus bool
	// ReclaimFocus moves focus back into the scope on rebuild when focus is
	// outside the scope after the initial autofocus.
	ReclaimFocus bool
	// Child is the scoped subtree.
	Child Widget
}

type FractionalMousePoint struct {
	// Col is the horizontal cell coordinate. Values may include a fractional
	// offset within the cell when pixel mouse reports are available.
	Col float64
	// Row is the vertical cell coordinate. Values may include a fractional
	// offset within the cell when pixel mouse reports are available.
	Row float64
}

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

type FuzzySelect[T any] struct {
	// Items are filtered, displayed, and activated by the picker.
	Items []T
	// Item converts an item into searchable and renderable row data.
	Item FuzzySelectItemFunc[T]
	// Filter filters and ranks Items for the current query. When nil,
	// DefaultFuzzySelectFilter is used.
	Filter FuzzySelectFilter[T]
	// Placeholder is shown in the search field when the query is empty.
	Placeholder string
	// EmptyText is shown when no items match the query.
	EmptyText string
	// Width is the panel content width when greater than zero.
	Width int
	// MaxVisibleRows limits visible result rows before scrolling.
	MaxVisibleRows int
	// RowStyle controls whether items render as one-line or two-line rows.
	RowStyle FuzzySelectRowStyle
	// OnDismiss is called when Escape is pressed.
	OnDismiss VoidCallback
	// OnSelected is called when an item is activated.
	OnSelected func(EventContext, T)
}

type FuzzySelectFilter[T any] func(query string, items []T, item FuzzySelectItemFunc[T]) []T

type FuzzySelectItem struct {
	// Title is the primary row text.
	Title string
	// Description is optional secondary row text.
	Description string
	// Aliases are additional strings matched by the default fuzzy filter.
	Aliases []string
	// Leading is painted before the title content when non-nil.
	Leading Widget
	// Trailing is painted at the end of the row when non-nil.
	Trailing Widget
	// Disabled prevents activation when true.
	Disabled bool
}

type FuzzySelectItemFunc[T any] func(T) FuzzySelectItem

type FuzzySelectRowStyle int

type HitTestResult struct{ Path []RenderObject }

type Image = vaxis.Image

type IndexedStack struct {
	// Index selects the visible child.
	Index int
	// Alignment places the visible child inside the stack. The zero value is
	// CenterAlign.
	Alignment Alignment
	// Children is the ordered child list.
	Children []Widget
}

type InsertLineBreakIntent struct{}

type InsertTextIntent struct {
	Text string
}

type Insets struct {
	Top, Right, Bottom, Left int
}

type Intent interface {
	IntentType() IntentType
}

type IntentType string

type Key = vaxis.Key

type KeyCallback func(EventContext, Key) EventResult

type KeyValue string

type Keyed interface {
	WidgetKey() KeyValue
}

type LayoutContext struct{}

type LeafRenderObject struct{ RenderObjectBase }

type ListTile struct {
	// Leading is painted before the title content when non-nil.
	Leading Widget
	// Title is the primary tile content.
	Title Widget
	// Subtitle is painted below Title when non-nil.
	Subtitle Widget
	// Trailing is painted at the end of the row when non-nil.
	Trailing Widget
	// Selected paints the tile with Theme primary colors.
	Selected bool
	// Disabled prevents focus, hover, and activation when true.
	Disabled bool
	// OnPressed is called when the tile is activated.
	OnPressed VoidCallback
	// Padding overrides the default tile padding when non-zero.
	Padding Insets
	// Gap overrides the default tile gap when greater than zero.
	Gap int
	// MinHeight overrides the default tile minimum height when greater than zero.
	MinHeight int
}

type ListTileTheme struct {
	Normal          Style
	Focused         Style
	Hovered         Style
	Selected        Style
	SelectedFocused Style
	SelectedHovered Style
	Disabled        Style
	Padding         Insets
	Gap             int
	MinHeight       int
	Mouse           MouseShape
}

type MainAxisAlignment int

type MainAxisSize int

type ModalBarrier struct {
	// Color is the scrim target color. The zero value defaults to black.
	Color Color
	// Opacity controls the blend amount from 0 to 255. The zero value defaults to
	// a subtle modal dimming opacity.
	Opacity uint8
}

type Mouse = vaxis.Mouse

type MouseButton = vaxis.MouseButton

type MouseShape = vaxis.MouseShape

type MouseShapeHandler interface {
	MouseShape(EventContext, Mouse) MouseShape
}

type MoveCaretIntent struct {
	Motion          TextMotion
	Unit            TextMotionUnit
	ExtendSelection bool
}

type MultiChildRenderObject struct {
	RenderObjectBase
	// contains filtered or unexported fields
}

type NextFocusIntent struct{}

type Offset struct{ X, Y int }

type Option func(*options)

type Overlay struct {
	// Child is the base subtree painted below all entries.
	Child Widget
	// Entries are painted in order above Child.
	Entries []OverlayEntry
}

type OverlayEntry struct {
	// Child is painted for this overlay entry.
	Child Widget
	// Modal inserts a barrier behind Child.
	Modal bool
	// Barrier overrides the default ModalBarrier when Modal is true.
	Barrier Widget
	// Alignment wraps Child in Align when non-zero.
	Alignment Alignment
}

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

type Palette struct {
	Neutral ColorScale
	Red     ColorScale
	Green   ColorScale
	Yellow  ColorScale
	Blue    ColorScale
	Magenta ColorScale
	Cyan    ColorScale
}

type ParentDataWidget interface {
	WidgetChild() Widget
	ApplyParentData(RenderObject)
}

type Point struct{ X, Y int }

type Positioned struct {
	// Left is the child X offset.
	Left int
	// Top is the child Y offset.
	Top int
	// Child is the positioned child.
	Child Widget
}

type PreviousFocusIntent struct{}

type PrimaryScreenAppender interface {
	Append([]byte)
	AppendString(string)
	AppendWriter() io.Writer
}

type PrimaryScreenRegionSizer interface {
	SetPrimaryScreenRegionHeight(int)
}

type ProgressBar struct {
	// Value is the completed fraction, from 0 to 1.
	Value float64
	// Width is used when greater than zero or when layout is unbounded.
	Width int
	// FilledStyle overrides the default progress filled style when non-zero.
	FilledStyle Style
	// EmptyStyle overrides the default progress empty style when non-zero.
	EmptyStyle Style
	// GradientStart is the filled color at the start of the bar when non-zero.
	GradientStart Color
	// GradientEnd is the filled color at the end of the bar when non-zero.
	GradientEnd Color
}

type ProgressBarTheme struct {
	Filled Style
	Empty  Style
}

type Provider[T any] struct {
	// Value is the value exposed to descendants.
	Value T
	// Child is the subtree that can depend on Value.
	Child Widget
	// ShouldNotify controls whether dependents rebuild after Value changes.
	ShouldNotify func(old, next T) bool
}

type Radio[T comparable] struct {
	// Value is the value represented by this radio.
	Value T
	// GroupValue is the currently selected value for the radio group.
	GroupValue T
	// Disabled prevents focus, hover, and activation when true.
	Disabled bool
	// Label is painted after the radio when non-empty.
	Label string
	// OnChanged is called with Value when the radio is activated.
	OnChanged ValueChangedCallback[T]
}

type Rect struct{ X, Y, Width, Height int }

type Redraw = vaxis.Redraw

type RenderObject interface {
	Base() *RenderObjectBase
	Layout(LayoutContext, Constraints)
	Paint(*Painter, Offset)
	HitTest(*HitTestResult, Point) bool
	VisitChildren(func(RenderObject))
}

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

type RenderObjectWidget interface {
	CreateRenderObject(BuildContext) RenderObject
	UpdateRenderObject(BuildContext, RenderObject)
}

type Resize = vaxis.Resize

type RichText struct {
	// Spans are the styled text runs to display.
	Spans []TextSpan
	// SoftWrap wraps text to the available width.
	SoftWrap bool
	// Overflow controls painting when text exceeds its layout bounds.
	Overflow TextOverflow
	// MaxLines limits the number of laid-out display lines when greater than zero.
	MaxLines int
	// Align controls horizontal placement within the laid-out width.
	Align TextAlign
}

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

type Runtime interface{ Dispatch(func()) }

type ScrollAlign int

type ScrollAxis int

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

type ScrollDirection int

type ScrollIntent struct {
	Axis      ScrollAxis
	Direction ScrollDirection
	Unit      ScrollUnit
}

type ScrollMetrics struct {
	// ScrollOffset is the current visible row or column on the active axis.
	ScrollOffset int
	// MaxScrollOffset is the largest valid scroll offset.
	MaxScrollOffset int
	// ViewportHeight is the visible row count.
	ViewportHeight int
	// ViewportWidth is the visible column count.
	ViewportWidth int
	// ContentHeight is the total scrollable row count.
	ContentHeight int
	// ContentWidth is the total scrollable column count.
	ContentWidth int
}

type ScrollPane struct {
	// Controller can be used to inspect and change the pane's row and column
	// offsets after it is mounted.
	Controller *ScrollPaneController
	// Child is laid out with unbounded width and height.
	Child Widget
}

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

type ScrollUnit int

type ScrollView struct {
	// Controller can be used to inspect and change the view's offset after it is
	// mounted.
	Controller *ScrollController
	// Axis controls which direction is scrollable. The zero value is vertical.
	Axis ScrollAxis
	// Child is laid out at the viewport cross-axis size with unbounded space
	// along Axis.
	Child Widget
}

type Scrollbar struct {
	// Axis controls which edge the scrollbar occupies. The zero value is
	// vertical.
	Axis ScrollAxis
	// Child is expected to expose ScrollMetrics from its render object.
	Child Widget
	// ThumbStyle overrides the default scrollbar thumb style when non-zero.
	ThumbStyle Style
	// TrackStyle overrides the default scrollbar track style when non-zero.
	TrackStyle Style
	// FocusedThumbStyle overrides the default focused scrollbar thumb style when non-zero.
	FocusedThumbStyle Style
	// FocusedTrackStyle overrides the default focused scrollbar track style when non-zero.
	FocusedTrackStyle Style
}

type ScrollbarTheme struct {
	Thumb        Style
	Track        Style
	FocusedThumb Style
	FocusedTrack Style
}

type Segment = vaxis.Segment

type SegmentedControl[T comparable] struct {
	// Value is the currently selected value.
	Value T
	// Segments is the ordered list of selectable segments.
	Segments []SegmentedItem[T]
	// Disabled prevents focus, hover, and activation for the whole control.
	Disabled bool
	// OnChanged is called when an enabled segment is selected.
	OnChanged ValueChangedCallback[T]
}

type SegmentedControlTheme struct {
	Normal          Style
	Focused         Style
	Hovered         Style
	Selected        Style
	SelectedHovered Style
	Disabled        Style
	Separator       Style
	Mouse           MouseShape
}

type SegmentedItem[T comparable] struct {
	// Value is reported through OnChanged when the segment is selected.
	Value T
	// Label is the text shown for the segment.
	Label string
	// Disabled prevents mouse and keyboard selection for this segment.
	Disabled bool
}

type SelectAllTextIntent struct{}

type SelectionArea struct {
	// Child is the subtree that can contain selectable text.
	Child Widget
}

type SelectionContainer struct {
	// Disabled excludes Child from ancestor SelectionArea traversal when true.
	Disabled bool
	// Child is the wrapped subtree.
	Child Widget
}

type ShortcutMap map[string]Intent

type Shortcuts struct {
	// Bindings maps Key.MatchString patterns to intents.
	Bindings ShortcutMap
	// Child is the subtree that receives events after unhandled shortcuts.
	Child Widget
}

type SingleChildRenderObject struct {
	RenderObjectBase
	// contains filtered or unexported fields
}

type Size struct{ Width, Height int }

type SizedBox struct {
	// Width and Height are the fixed size requested for the child. Values less
	// than or equal to zero leave that axis unconstrained by the SizedBox.
	Width, Height int
	// Child is laid out with tight constraints for specified axes.
	Child Widget
}

type SliverConstraints struct {
	// ViewportWidth is the available width in cells.
	ViewportWidth int
	// ViewportHeight is the viewport height in cells.
	ViewportHeight int
	// RemainingPaintExtent is the number of viewport rows left after previous
	// slivers.
	RemainingPaintExtent int
	// ScrollOffset is the number of rows scrolled into this sliver.
	ScrollOffset int
	// ObscuredLeadingExtent is the number of rows from this sliver's leading
	// edge that are hidden by viewport clipping or pinned content.
	ObscuredLeadingExtent int
}

type SliverFillRemaining struct {
	// Child is laid out at the viewport width and fills any remaining rows.
	Child Widget
}

type SliverGeometry struct {
	// ScrollExtent is the sliver's total logical height in rows.
	ScrollExtent int
	// PaintExtent is the number of rows this sliver can paint in the viewport.
	PaintExtent int
	// ScrollOffsetCorrection adjusts the viewport offset after newly measured
	// content changes the logical position of the current anchor row.
	ScrollOffsetCorrection int
}

type SliverList struct {
	// Children are laid out vertically in order.
	Children []Widget
}

type SliverListBuilder struct {
	// Controller can be used to inspect and scroll this list by item index
	// after it is mounted in a CustomScrollView.
	Controller *SliverListController
	// Count is the number of logical rows available from Builder.
	Count int
	// ItemExtent is the fixed height of each item in cells when greater than
	// zero.
	ItemExtent int
	// EstimatedItemExtent is the height used for unmeasured rows when
	// ItemExtent is zero. A zero or negative value is treated as one row.
	EstimatedItemExtent int
	// Overscan builds this many extra items before and after the viewport.
	Overscan int
	// Builder returns the widget for index. It is only called for the active
	// visible range plus Overscan.
	Builder func(BuildContext, int) Widget
}

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

type SliverPinnedHeader struct {
	// Child is laid out at the viewport width with its natural height.
	Child Widget
}

type SliverTableBuilder struct {
	// Controller can be used to inspect and scroll this table by row index after
	// it is mounted in a CustomScrollView.
	Controller *SliverTableController
	// Columns controls each column's width. Missing columns are intrinsic.
	Columns []TableColumn
	// RowCount is the number of logical rows available from Builder.
	RowCount int
	// Builder returns the table row for row. It is only called for the active
	// visible range plus Overscan.
	Builder func(BuildContext, int) TableRow
	// EstimatedRowExtent is the height used for unmeasured rows. A zero or
	// negative value is treated as one row.
	EstimatedRowExtent int
	// Overscan builds this many extra rows before and after the viewport.
	Overscan int
}

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

type SliverToBox struct {
	// Child is laid out at the viewport width with unbounded height.
	Child Widget
}

type Stack struct {
	// Alignment places non-positioned children inside the stack. The zero value
	// is CenterAlign.
	Alignment Alignment
	// Children is the ordered back-to-front child list.
	Children []Widget
}

type StackParentData struct {
	// Positioned reports whether Left and Top should be used.
	Positioned bool
	// Left is the positioned X offset.
	Left int
	// Top is the positioned Y offset.
	Top int
	// Offset is the child paint offset computed by renderStack.
	Offset Offset
}

type State interface{ Build(BuildContext) Widget }

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

type StateDisposer interface{ Dispose() }

type StateInitializer interface{ InitState() }

type StateUpdater interface{ DidUpdateWidget(old Widget) }

type StatefulWidget interface{ CreateState() State }

type StatelessWidget interface{ Build(BuildContext) Widget }

type Style = vaxis.Style

type SyncFunc = vaxis.SyncFunc

type Table struct {
	Columns   []TableColumn
	ColumnGap int
	RowGap    int
	Rows      []TableRow
}

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

type TableParentData struct {
	Offset Offset
}

type TableRow struct {
	Children []Widget
}

type Text struct {
	// Value is the string to display.
	Value string
	// Style overrides Theme foreground when non-zero fields are set.
	Style Style
	// ClickAffordance controls the visual affordance added when OnPressed is set.
	ClickAffordance ClickAffordance
	// SoftWrap wraps text to the available width.
	SoftWrap bool
	// Overflow controls painting when text exceeds its layout bounds.
	Overflow TextOverflow
	// MaxLines limits the number of laid-out display lines when greater than zero.
	MaxLines int
	// Align controls horizontal placement within the laid-out width.
	Align TextAlign
	// OnPressed is called when the visible text is clicked or activated while focused.
	OnPressed VoidCallback
}

type TextAlign int

type TextArea struct {
	// Value is the current text. The widget does not mutate this field directly.
	Value string
	// Placeholder is shown when Value is empty and the area is not focused.
	Placeholder string
	// OnChanged is called with the next value after an edit.
	OnChanged TextChangedCallback
	// Padding overrides the default text field padding when non-zero.
	Padding Insets
	// MinWidth overrides the default text field minimum width when greater than zero.
	MinWidth int
	// MinHeight is the minimum content height, before padding.
	MinHeight int
	// MaxHeight is the maximum content height, before padding. When greater than zero,
	// the text area grows until MaxHeight and then scrolls internally.
	MaxHeight int
	// SoftWrap wraps long logical lines to the available width.
	SoftWrap bool
	// CursorOffset moves the cursor to a grapheme offset and clears selection when non-nil.
	CursorOffset *int
	// Selection sets the active selection and cursor when non-nil.
	Selection *TextSelection
	// CursorShape overrides the cursor shape while focused. Zero uses CursorBeam.
	CursorShape CursorStyle
	// AutoFocus requests focus when the text area is mounted.
	AutoFocus bool
}

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