🥮 mooncakes.io
    Sign in

    wzzc-dev/moui/core does not have a README file

    TextGraphemeBoundaries

    source

    The grapheme boundary scanner, backed by the Unicode 17.0 property table.

    AccessibilityContrast

    source
    pub(all) enum AccessibilityContrast {
      Standard
      High
    } derive(Eq, ToJson, 
    Debug    )

    ActionCommand

    source
    pub(all) struct ActionCommand {
      intent : CommandIntent
      shortcut : KeyboardShortcut?
      label : String
      enabled : Bool
      group : String
      description : String
      context_menu : Bool
    } derive(Eq, ToJson, 
    Debug    )

    ActionCommand::display_label

    source
    fn ActionCommand::display_label(self : ActionCommand) -> String

    ActionCommand::matches

    source
    fn ActionCommand::matches(self : ActionCommand, event : KeyboardEvent) -> Bool

    ActionCommand::new

    source
    fn ActionCommand::new(intent~ : CommandIntent, label? : String, shortcut? : KeyboardShortcut?, enabled? : Bool, group? : String, description? : String, context_menu? : Bool) -> ActionCommand

    ActionCommand::shortcut_label

    source
    fn ActionCommand::shortcut_label(self : ActionCommand) -> String

    ActionCommandMap

    source
    type ActionCommandMap

    ActionCommandMap::commands

    source

    ActionCommandMap::dispatch_command

    source
    fn ActionCommandMap::dispatch_command(self : ActionCommandMap, command : ActionCommand) -> Bool

    ActionCommandMap::dispatch_intent

    source
    fn ActionCommandMap::dispatch_intent(self : ActionCommandMap, intent : CommandIntent) -> Bool

    ActionCommandMap::dispatch_shortcut

    source
    fn ActionCommandMap::dispatch_shortcut(self : ActionCommandMap, event : KeyboardEvent) -> CommandIntent?

    ActionCommandMap::find_shortcut

    source
    fn ActionCommandMap::find_shortcut(self : ActionCommandMap, event : KeyboardEvent) -> ActionCommand?

    ActionCommandMap::new

    source

    Alignment

    source
    pub(all) struct Alignment {
      x : Double
      y : Double
    } derive(Eq, ToJson, 
    Debug    )

    Alignment::bottom_leading

    source
    fn Alignment::bottom_leading() -> Alignment

    Alignment::bottom_trailing

    source
    fn Alignment::bottom_trailing() -> Alignment

    Alignment::center

    source
    fn Alignment::center() -> Alignment

    Alignment::new

    source
    fn Alignment::new(x~ : Double, y~ : Double) -> Alignment

    Alignment::top_leading

    source
    fn Alignment::top_leading() -> Alignment

    Alignment::top_trailing

    source
    fn Alignment::top_trailing() -> Alignment

    AlignmentGuideSet

    source
    pub(all) struct AlignmentGuideSet {
      leading : Double
      center : Double
      trailing : Double
      first_baseline : Double?
    } derive(Eq, ToJson, 
    Debug    )

    AlignmentGuideSet::from_size

    source
    fn AlignmentGuideSet::from_size(size : Size, first_baseline? : Double?) -> AlignmentGuideSet

    AnimationStatus

    source
    pub(all) enum AnimationStatus {
      Idle
      Running
      Completed
    } derive(Eq, ToJson, 
    Debug    )

    AppEvent

    source
    pub(all) enum AppEvent {
      FrameTick(Frame)
      Pointer(PointerEvent)
      Keyboard(KeyboardEvent)
      TextInput(TextInputEvent)
      DragDrop(DragDropEvent)
      PlatformView(String, PlatformViewEvent)
      Resize(Size)
      Redraw(RedrawReason)
      CloseRequested
    } derive(Eq, ToJson, 
    Debug    )

    Axis

    source
    pub(all) enum Axis {
      Horizontal
      Vertical
    } derive(Eq, ToJson, 
    Debug    )

    BadgeTheme

    source
    pub(all) struct BadgeTheme {
      neutral : ToneTokens
      accent : ToneTokens
      success : ToneTokens
      warning : ToneTokens
      danger : ToneTokens
      radius : Double
      padding : Double
    } derive(Eq, ToJson, 
    Debug    )

    Binding

    source
    pub struct Binding[T] {
      // private fields
    }

    Binding::get

    source
    fn[T] Binding::get(self : Binding[T]) -> T

    Binding::new

    source
    fn[T] Binding::new(get~ : () -> T, set~ : (T) -> Unit) -> Binding[T]

    Binding::set

    source
    fn[T] Binding::set(self : Binding[T], value : T) -> Unit

    Binding::update

    source
    fn[T] Binding::update(self : Binding[T], f : (T) -> T raise?) -> Unit raise?

    BlendMode

    source
    pub(all) enum BlendMode {
      SourceOver
      Multiply
      Screen
      Overlay
      Darken
      Lighten
    } derive(Eq, ToJson, 
    Debug    )

    BorderStyle

    source
    pub(all) struct BorderStyle {
      brush : Brush
      width : Double
    } derive(Eq, ToJson, 
    Debug    )

    BorderStyle::new

    source
    fn BorderStyle::new(brush~ : Brush, width? : Double) -> BorderStyle

    Brush

    source
    pub(all) enum Brush {
      Solid(Color)
      LinearGradient(LinearGradientSpec)
      RadialGradient(RadialGradientSpec)
    } derive(Eq, ToJson, 
    Debug    )

    Brush::fallback_color

    source
    fn Brush::fallback_color(self : Brush) -> Color

    Brush::linear_gradient

    source
    fn Brush::linear_gradient(start~ : Point, end~ : Point, start_color~ : Color, end_color~ : Color) -> Brush

    Brush::multiply_alpha

    source
    fn Brush::multiply_alpha(self : Brush, opacity : Double) -> Brush

    Brush::radial_gradient

    source
    fn Brush::radial_gradient(center~ : Point, radius~ : Double, center_color~ : Color, edge_color~ : Color) -> Brush

    Brush::solid

    source
    fn Brush::solid(color : Color) -> Brush

    ButtonState

    source
    pub(all) enum ButtonState {
      Normal
      Hovered
      Pressed
    } derive(Eq, ToJson, 
    Debug    )

    ButtonState::to_interaction

    source
    fn ButtonState::to_interaction(self : ButtonState) -> InteractionState

    Convert a runtime ButtonState (gesture-driven three-state) into the token-layer InteractionState for button resolution.

    ButtonTheme

    source
    pub(all) struct ButtonTheme {
      primary : ControlStateTokens
      tonal : ControlStateTokens
      outline : ControlStateTokens
      ghost : ControlStateTokens
      subtle : ControlStateTokens
      subtle_brand : ControlStateTokens
      state_layer : StateLayerTokens
    } derive(Eq, ToJson, 
    Debug    )

    Button variant tokens. Each variant carries its own ControlStateTokens for the normal state; hover/press/disabled are derived from the state-layer model (see ButtonTheme::resolve). Fluent 2 fills subtle/subtle_brand distinctly; neutral presets alias them to ghost/tonal.

    ButtonTheme::resolve

    source

    Resolve a button variant + interaction state into a paint-ready ControlStateStyle. Hover/press/disabled are derived from the variant's normal tokens via the state-layer model so every variant shares a uniform interaction grammar.

    ButtonVariantToken

    source
    pub(all) enum ButtonVariantToken {
      Primary
      Tonal
      Outline
      Ghost
      Subtle
      SubtleBrand
    } derive(Eq, ToJson, 
    Debug    )

    CachedLayerSpec

    source
    pub(all) struct CachedLayerSpec {
      key : String
      frame : Rect
      content_revision : Int
      scale_factor : Double
    } derive(Eq, ToJson, 
    Debug    )

    CachedLayerSpec::new

    source
    fn CachedLayerSpec::new(key~ : String, frame~ : Rect, content_revision~ : Int, scale_factor? : Double) -> CachedLayerSpec

    CheckMarkStyle

    source
    pub(all) enum CheckMarkStyle {
      Checkmark
      Dot
    } derive(Eq, ToJson, 
    Debug    )

    How a selected choice control marks itself. Checkmark draws a "✓" glyph on the filled box; Dot draws a small filled inner circle (radio style).

    CheckMarkStyle::label

    source
    fn CheckMarkStyle::label(self : CheckMarkStyle) -> String

    ChoiceControlShape

    source
    pub(all) enum ChoiceControlShape {
      Square
      Circle
    } derive(Eq, ToJson, 
    Debug    )

    Shape of a choice-control box (checkbox/radio). Square draws a rounded rectangle; Circle draws a full circle. Fluent 2 radios use Circle, checkboxes use Square.

    ChoiceControlShape::label

    source
    fn ChoiceControlShape::label(self : ChoiceControlShape) -> String

    Short label for revision/identity strings.

    ChoiceControlTheme

    source
    pub(all) struct ChoiceControlTheme {
      foreground : Color
      selected_color : Color
      disabled_foreground : Color
      disabled_selected_color : Color
      control_size : Double
      box_shape : ChoiceControlShape
      check_style : CheckMarkStyle
    } derive(Eq, ToJson, 
    Debug    )

    Color

    source
    pub(all) struct Color {
      r : Double
      g : Double
      b : Double
      a : Double
    } derive(Eq, ToJson, 
    Debug    )

    Color::black

    source
    fn Color::black() -> Color

    Color::blue

    source
    fn Color::blue() -> Color

    Color::darken

    source
    fn Color::darken(self : Color, amount : Double) -> Color

    Blend this color toward black by amount (clamped to 0..1). Useful for deriving press/active shades from a base palette color.

    Color::gray

    source
    fn Color::gray() -> Color

    Color::lerp

    source
    fn Color::lerp(self : Color, other : Color, t : Double) -> Color

    Linearly interpolate between this color and other by t (clamped to 0..1). t = 0 returns self, t = 1 returns other. Used to derive hover/press shades and drive color transitions without a full animation pipeline.

    Color::lighten

    source
    fn Color::lighten(self : Color, amount : Double) -> Color

    Blend this color toward white by amount (clamped to 0..1). Useful for deriving hover shades from a base palette color.

    Color::mix

    source
    fn Color::mix(self : Color, other : Color, weight : Double) -> Color

    Alias of Color::lerp with the conventional weight naming: a weight of 0.0 keeps self, 1.0 fully adopts other.

    Color::multiply_alpha

    source
    fn Color::multiply_alpha(self : Color, opacity : Double) -> Color

    Color::rgba

    source
    fn Color::rgba(r~ : Double, g~ : Double, b~ : Double, a? : Double) -> Color

    Color::white

    source
    fn Color::white() -> Color

    Color::with_alpha

    source
    fn Color::with_alpha(self : Color, alpha : Double) -> Color

    ColorMode

    source
    pub(all) enum ColorMode {
      Light
      Dark
      System
    } derive(Eq, ToJson, 
    Debug    )

    Color mode: force light, force dark, or follow the system.

    ColorPalette

    source
    pub(all) struct ColorPalette {
      foreground : Color
      background : Color
      surface : Color
      surface_variant : Color
      primary : Color
      on_primary : Color
      primary_container : Color
      on_primary_container : Color
      secondary : Color
      on_secondary : Color
      secondary_container : Color
      on_secondary_container : Color
      tertiary : Color
      on_tertiary : Color
      tertiary_container : Color
      on_tertiary_container : Color
      error : Color
      on_error : Color
      error_container : Color
      on_error_container : Color
      on_foreground : Color
      on_surface : Color
      on_surface_variant : Color
      outline : Color
      outline_variant : Color
      muted : Color
      success : Color
      on_success : Color
      warning : Color
      on_warning : Color
      info : Color
      on_info : Color
      danger : Color
      on_danger : Color
      focus : Color
      scrim : Color
    } derive(Eq, ToJson, 
    Debug    )

    Full semantic color palette. Extended from the original 8-role palette to the complete on*/container matrix used by Material 3 / Fluent 2 so a branded design system can express primary/secondary/tertiary/error container pairs and their on-colors instead of deriving them ad hoc with multiply_alpha/lerp. Semantic colors (success/warning/danger/info) are folded in directly; the separate SemanticColorScale is removed.

    Role naming follows Compose Material 3 ColorScheme:
    • on_<role> is the text/icon color drawn on top of <role>.
    • <role>_container is a tinted surface variant; on_<role>_container is the text color on that container. on_foreground is an explicit alias of background for symmetry.

    ColorPalette::dark

    source

    Minimal dark palette (zinc neutrals, near-white primary). Mirrors light.

    ColorPalette::from_seed

    source
    fn ColorPalette::from_seed(primary~ : Color, scheme : ColorScheme, foreground? : Color, background? : Color, surface? : Color, surface_variant? : Color, outline? : Color, muted? : Color) -> ColorPalette

    Build a palette from a primary color and scheme, deriving every on*/container role programmatically. This is the shared derivation used by both the Minimal preset and (optionally) branded addons that want a seed-driven palette without hand-writing 30+ colors.

    Derivation rules:
    • on_primary/on_secondary/on_tertiary/on_error = white on dark primaries, near-black on light primaries (contrast-aware).
    • <role>_container = the role color lerped toward the surface by ~0.85 (a soft tint); on_<role>_container = the role color darkened (light) or lightened (dark) for legibility on the tint.
    • secondary/tertiary default to a desaturated primary analog so the palette stays coherent when only a seed is supplied.

    ColorPalette::light

    source
    fn ColorPalette::light() -> ColorPalette

    Minimal light palette (zinc neutrals, near-black primary). Equivalent to the legacy hand-written palette but now fills the full on*/container matrix via from_seed.

    ColorScheme

    source
    pub(all) enum ColorScheme {
      Light
      Dark
    } derive(Eq, ToJson, 
    Debug    )

    CommandBinding

    source
    type CommandBinding

    CommandBinding::new

    source
    fn CommandBinding::new(command~ : ActionCommand, handle~ : () -> Unit) -> CommandBinding

    CommandIntent

    source
    pub(all) enum CommandIntent {
      Activate
      Submit
      Cancel
      Copy
      Cut
      Paste
      Undo
      Redo
      SelectAll
      OpenContextMenu
    } derive(Eq, ToJson, 
    Debug    )

    CommandIntent::display_label

    source
    fn CommandIntent::display_label(self : CommandIntent) -> String

    ComponentContext

    source
    pub struct ComponentContext {
      // private fields
    }

    ComponentContext::accessibility_contrast

    source
    fn ComponentContext::accessibility_contrast(self : ComponentContext) -> AccessibilityContrast

    ComponentContext::binding

    source
    fn[T] ComponentContext::binding(self : ComponentContext, state : State[T]) -> Binding[T]

    ComponentContext::color_scheme

    source
    fn ComponentContext::color_scheme(self : ComponentContext) -> ColorScheme

    ComponentContext::content_size_category

    source
    fn ComponentContext::content_size_category(self : ComponentContext) -> ContentSizeCategory

    ComponentContext::enabled

    source
    fn ComponentContext::enabled(self : ComponentContext) -> Bool

    ComponentContext::environment

    source
    fn ComponentContext::environment(self : ComponentContext) -> Environment

    ComponentContext::from_runtime

    source

    ComponentContext::layout_direction

    source
    fn ComponentContext::layout_direction(self : ComponentContext) -> LayoutDirection

    ComponentContext::locale

    source
    fn ComponentContext::locale(self : ComponentContext) -> String

    ComponentContext::on_dispose

    source
    fn ComponentContext::on_dispose(self : ComponentContext, key~ : String, cleanup : () -> Unit) -> Unit

    ComponentContext::on_mount

    source
    fn ComponentContext::on_mount(self : ComponentContext, key~ : String, effect : () -> Unit) -> Unit

    ComponentContext::on_unmount

    source
    fn ComponentContext::on_unmount(self : ComponentContext, key~ : String, cleanup : () -> Unit) -> Unit

    ComponentContext::on_unmount_with_reason

    source
    fn ComponentContext::on_unmount_with_reason(self : ComponentContext, key~ : String, cleanup : (ComponentEffectCancelReason) -> Unit) -> Unit

    ComponentContext::on_update

    source
    fn ComponentContext::on_update(self : ComponentContext, key~ : String, deps~ : Array[String], effect : () -> () -> Unit?) -> Unit

    ComponentContext::on_update_with_reason

    source
    fn ComponentContext::on_update_with_reason(self : ComponentContext, key~ : String, deps~ : Array[String], effect : () -> (ComponentEffectCancelReason) -> Unit?) -> Unit

    ComponentContext::reduced_motion

    source
    fn ComponentContext::reduced_motion(self : ComponentContext) -> Bool

    ComponentContext::restore

    source
    fn[T] ComponentContext::restore(self : ComponentContext, key~ : String, codec : SaveableCodec[T]) -> T?

    ComponentContext::restore_bool

    source
    fn ComponentContext::restore_bool(self : ComponentContext, key~ : String) -> Bool?

    ComponentContext::restore_int

    source
    fn ComponentContext::restore_int(self : ComponentContext, key~ : String) -> Int?

    ComponentContext::restore_string

    source
    fn ComponentContext::restore_string(self : ComponentContext, key~ : String) -> String?

    ComponentContext::run_effect

    source
    fn ComponentContext::run_effect(self : ComponentContext, key~ : String, effect : () -> () -> Unit?) -> Unit

    ComponentContext::run_effect_with_reason

    source
    fn ComponentContext::run_effect_with_reason(self : ComponentContext, key~ : String, effect : () -> (ComponentEffectCancelReason) -> Unit?) -> Unit

    ComponentContext::save

    source
    fn[T] ComponentContext::save(self : ComponentContext, key~ : String, value : T, codec : SaveableCodec[T]) -> Unit

    ComponentContext::save_bool

    source
    fn ComponentContext::save_bool(self : ComponentContext, key~ : String, value : Bool) -> Unit

    ComponentContext::save_int

    source
    fn ComponentContext::save_int(self : ComponentContext, key~ : String, value : Int) -> Unit

    ComponentContext::save_string

    source
    fn ComponentContext::save_string(self : ComponentContext, key~ : String, value : String) -> Unit

    ComponentContext::saveable

    source
    fn[T] ComponentContext::saveable(self : ComponentContext, key~ : String, initial : T, codec : SaveableCodec[T]) -> State[T]

    ComponentContext::saveable_bool

    source
    fn ComponentContext::saveable_bool(self : ComponentContext, key~ : String, initial : Bool) -> State[Bool]

    ComponentContext::saveable_int

    source
    fn ComponentContext::saveable_int(self : ComponentContext, key~ : String, initial : Int) -> State[Int]

    ComponentContext::saveable_string

    source
    fn ComponentContext::saveable_string(self : ComponentContext, key~ : String, initial : String) -> State[String]

    ComponentContext::scale_factor

    source
    fn ComponentContext::scale_factor(self : ComponentContext) -> Double

    ComponentContext::text_scale

    source
    fn ComponentContext::text_scale(self : ComponentContext) -> Double

    ComponentContext::theme

    source

    ComponentContext::view_environment

    source
    fn ComponentContext::view_environment(self : ComponentContext) -> ViewEnvironment

    ComponentContext::viewport_size

    source
    fn ComponentContext::viewport_size(self : ComponentContext) -> Size

    ComponentContext::watch

    source
    fn[T] ComponentContext::watch(self : ComponentContext, state : State[T]) -> T

    ComponentContext::watch_derived

    source
    fn[T] ComponentContext::watch_derived(self : ComponentContext, state : DerivedState[T]) -> T

    ComponentContext::watch_focus

    source
    fn ComponentContext::watch_focus(self : ComponentContext, state : FocusState) -> String?

    ComponentContext::watch_navigation

    source
    fn ComponentContext::watch_navigation(self : ComponentContext, state : NavigationState) -> Array[String]

    ComponentContext::watch_scroll

    source
    fn ComponentContext::watch_scroll(self : ComponentContext, state : ScrollState) -> Point

    ComponentEffect

    source
    type ComponentEffect

    ComponentEffect::finish_reuse

    source
    fn ComponentEffect::finish_reuse(old_effects : Array[ComponentEffect], reason? : ComponentEffectCancelReason, cancel_reused? : Bool) -> Unit

    ComponentEffectCancelReason

    source
    pub(all) enum ComponentEffectCancelReason {
      EffectKeyChanged
      EffectUnmounted
      EffectRuntimeDestroyed
    } derive(Eq, ToJson, 
    Debug    )

    ComponentRuntimeContextInput

    source
    pub(all) struct ComponentRuntimeContextInput {
      component_id : ElementId
      request_component_rebuild : (ElementId) -> Unit
      viewport_size : Size
      saveable_state : SaveableStateStore
      subscriptions : Array[StateSubscription]
      effects : Array[ComponentEffect]
      old_effects : Array[ComponentEffect]
      environment : Environment
    }

    ComponentThemes

    source
    pub(all) struct ComponentThemes {
      button : ButtonTheme
      text_field : TextFieldTheme
      surface : SurfaceTheme
      choice_control : ChoiceControlTheme
      progress : ProgressTheme
      slider : SliderTheme
      picker : PickerTheme
      feedback : FeedbackTheme
      badge : BadgeTheme
      form_validation : FormValidationTheme
    } derive(Eq, ToJson, 
    Debug    )

    First-class component theme aggregate carried by Theme. Each field is a per-control token set; controls resolve variant/state at paint time via the resolve methods above. An app that wants a branded design system sets this once on the root theme and every control inherits it.

    CompositionUpdate

    source
    type CompositionUpdate derive(Eq, ToJson, 
    Debug    )

    CompositionUpdate::cursor

    source

    CompositionUpdate::new

    source
    fn CompositionUpdate::new(text~ : String, cursor? : TextRange?) -> CompositionUpdate

    CompositionUpdate::text

    source
    fn CompositionUpdate::text(self : CompositionUpdate) -> String

    Constraints

    source
    pub(all) struct Constraints {
      min : Size
      max : Size
    } derive(Eq, ToJson, 
    Debug    )

    Constraints::constrain

    source
    fn Constraints::constrain(self : Constraints, size : Size) -> Size

    Constraints::deflate

    source
    fn Constraints::deflate(self : Constraints, insets : Insets) -> Constraints

    Constraints::is_tight

    source
    fn Constraints::is_tight(self : Constraints) -> Bool

    Constraints::loose

    source
    fn Constraints::loose(max : Size) -> Constraints

    Constraints::loosen

    source
    fn Constraints::loosen(self : Constraints) -> Constraints

    Constraints::tight

    source
    fn Constraints::tight(size : Size) -> Constraints

    Constraints::tighten

    source
    fn Constraints::tighten(self : Constraints, width? : Double, height? : Double) -> Constraints

    Constraints::unbounded

    source
    fn Constraints::unbounded() -> Constraints

    ContentSizeCategory

    source
    pub(all) enum ContentSizeCategory {
      Small
      Medium
      Large
      ExtraLarge
      Accessibility
    } derive(Eq, ToJson, 
    Debug    )

    ContentSizeCategory::text_scale

    source
    fn ContentSizeCategory::text_scale(self : ContentSizeCategory) -> Double

    ControlStateStyle

    source
    pub(all) struct ControlStateStyle {
      foreground : Color
      background : Brush
      border : BorderStyle?
      radius : Double
      shadow : ShadowStyle?
      bottom_border_only : Bool
      inner_focus_border : Color?
    } derive(Eq, ToJson, 
    Debug    )

    Resolved per-state style. Paint layer: background is a Brush, border is None when border_width == 0.0. This is the type controls actually consume when emitting DrawCommands.

    ControlStateTokens

    source
    pub(all) struct ControlStateTokens {
      foreground : Color
      background : Color
      border : Color
      border_width : Double
      radius : Double
      bottom_border_only : Bool
      inner_focus_border : Color?
    } derive(Eq, ToJson, 
    Debug    )

    Raw per-state token. Token layer: colors are plain Color, background is a Color (paint resolves it to Brush::solid). border_width == 0.0 means "no border". bottom_border_only paints only the bottom edge (Fluent 2 underline inputs). inner_focus_border paints an inner stroke inside the control frame on focus (Fluent 2 focus reveal).

    ControlStateTokens::new

    source
    fn ControlStateTokens::new(foreground~ : Color, background~ : Color, border~ : Color, border_width~ : Double, radius~ : Double, bottom_border_only? : Bool, inner_focus_border? : Color?) -> ControlStateTokens

    Convenience constructor for ControlStateTokens.

    ControlStateTokens::resolve

    source

    Resolve a token set into a paint-ready ControlStateStyle. The border is dropped when border_width <= 0.0. shadow is always None here; layered shadows are attached by the component theme that owns the token (e.g. SurfaceTheme), not by individual control states.

    CrossAxisAlignment

    source
    pub(all) enum CrossAxisAlignment {
      CrossStart
      CrossCenter
      CrossEnd
      CrossStretch
    } derive(Eq, ToJson, 
    Debug    )

    CustomLayoutCache

    source
    type CustomLayoutCache

    CustomLayoutCache::clear

    source
    fn CustomLayoutCache::clear(self : CustomLayoutCache) -> Unit

    CustomLayoutCache::get

    source
    fn CustomLayoutCache::get(self : CustomLayoutCache, key : String) -> String?

    CustomLayoutCache::new

    source

    CustomLayoutCache::set

    source
    fn CustomLayoutCache::set(self : CustomLayoutCache, key : String, value : String) -> Unit

    CustomLayoutContext

    source
    pub(all) struct CustomLayoutContext {
      constraints : Constraints
      child_sizes : Array[Size]
      child_baselines : Array[Double?]
      child_priorities : Array[Double]
      child_alignment_guides : Array[AlignmentGuideSet]
      cache : CustomLayoutCache
      cache_key : String
      layout_direction : LayoutDirection
      safe_area : Insets
      viewport : Size?
    }

    CustomPlacementContext

    source
    pub(all) struct CustomPlacementContext {
      frame : Rect
      measured_size : Size
      child_sizes : Array[Size]
      child_baselines : Array[Double?]
      child_priorities : Array[Double]
      child_alignment_guides : Array[AlignmentGuideSet]
      cache : CustomLayoutCache
      cache_key : String
      layout_direction : LayoutDirection
      safe_area : Insets
      viewport : Size?
    }

    CustomPlacementContext::mirror_x

    source
    fn CustomPlacementContext::mirror_x(self : CustomPlacementContext, x~ : Double, width~ : Double) -> Double

    DamageRegion

    source
    pub(all) enum DamageRegion {
      Empty
      FullSurface(String)
      Rects(Array[Rect])
    } derive(Eq, ToJson, 
    Debug    )

    DamageRegion::empty

    source
    fn DamageRegion::empty() -> DamageRegion

    DamageRegion::from_rects

    source
    fn DamageRegion::from_rects(rects : Array[Rect], surface : Rect) -> DamageRegion

    DamageRegion::full

    source
    fn DamageRegion::full(reason : String) -> DamageRegion

    DamageRegion::full_reason

    source
    fn DamageRegion::full_reason(self : DamageRegion) -> String

    DamageRegion::kind

    source
    fn DamageRegion::kind(self : DamageRegion) -> String

    DamageRegion::rect_count

    source
    fn DamageRegion::rect_count(self : DamageRegion) -> Int

    DateValue

    source
    pub(all) struct DateValue {
      year : Int
      month : Int
      day : Int
      hour : Int
      minute : Int
      second : Int
    } derive(Eq, ToJson, 
    Debug    )

    DateValue::format_date

    source
    fn DateValue::format_date(self : DateValue) -> String

    DateValue::format_date_time

    source
    fn DateValue::format_date_time(self : DateValue) -> String

    DateValue::format_time

    source
    fn DateValue::format_time(self : DateValue) -> String

    DateValue::new

    source
    fn DateValue::new(year~ : Int, month~ : Int, day~ : Int, hour? : Int, minute? : Int, second? : Int) -> DateValue

    DerivedState

    source
    pub struct DerivedState[T] {
      // private fields
    }

    DerivedState::combine

    source
    fn[A, B, T] DerivedState::combine(left : State[A], right : State[B], project : (A, B) -> T) -> DerivedState[T]

    DerivedState::from_state

    source
    fn[T, U] DerivedState::from_state(state : State[T], project : (T) -> U) -> DerivedState[U]

    DerivedState::get

    source
    fn[T] DerivedState::get(self : DerivedState[T]) -> T

    DerivedState::new

    source
    fn[T] DerivedState::new(get~ : () -> T, subscribe~ : (() -> Unit) -> Array[StateSubscription]) -> DerivedState[T]

    DerivedState::subscribe

    source
    fn[T] DerivedState::subscribe(self : DerivedState[T], callback : () -> Unit) -> Array[StateSubscription]

    DragDropEvent

    source
    pub(all) struct DragDropEvent {
      phase : DragDropPhase
      paths : Array[String]
      position : Point?
    } derive(Eq, ToJson, 
    Debug    )

    DragDropEvent::new

    source
    fn DragDropEvent::new(phase~ : DragDropPhase, paths? : Array[String], position? : Point?) -> DragDropEvent

    DragDropPhase

    source
    pub(all) enum DragDropPhase {
      Entered
      Moved
      Dropped
      Left
    } derive(Eq, ToJson, 
    Debug    )

    DragGestureEvent

    source
    pub(all) struct DragGestureEvent {
      phase : DragGesturePhase
      start : Point
      position : Point
      delta : Point
      translation : Point
    } derive(Eq, ToJson, 
    Debug    )

    DragGestureEvent::new

    source
    fn DragGestureEvent::new(phase~ : DragGesturePhase, start~ : Point, position~ : Point, delta~ : Point, translation~ : Point) -> DragGestureEvent

    DragGesturePhase

    source
    pub(all) enum DragGesturePhase {
      Idle
      Pending
      Started
      Changed
      Ended
      Cancelled
    } derive(Eq, ToJson, 
    Debug    )

    DragGesturePhase::label

    source
    fn DragGesturePhase::label(self : DragGesturePhase) -> String

    DrawCommand

    source
    pub(all) enum DrawCommand {
      Clear(Color)
      FillRect(Rect, Color)
      StrokeRect(Rect, Color, Double)
      FillRoundedRect(RoundedRect, Color)
      StrokeRoundedRect(RoundedRect, Color, Double)
      FillRoundedRectBrush(RoundedRect, Brush)
      StrokeRoundedRectBrush(RoundedRect, Brush, Double)
      DrawShadow(ShadowSpec)
      DrawText(TextRun)
      DrawImage(ImageRun)
      PushClip(Rect)
      PopClip
      PushRoundedClip(RoundedRect)
      PopRoundedClip
      PushTransform(Transform2D)
      PopTransform
      PushOpacity(Double)
      PopOpacity
      PushLayer(LayerSpec)
      PopLayer
      BeginCachedLayer(CachedLayerSpec)
      EndCachedLayer(String)
      DrawCachedLayer(CachedLayerSpec)
      PushFilter(FilterEffect)
      PopFilter
      DrawPath(PathSpec)
      DrawShaderEffect(ShaderEffectSpec)
    } derive(Eq, ToJson, 
    Debug    )

    DrawCommand::bounds

    source
    fn DrawCommand::bounds(self : DrawCommand) -> Rect?

    DrawFrame

    source
    pub(all) struct DrawFrame {
      commands : Array[DrawCommand]
      platform_views : Array[PlatformViewPlacement]
      damage : DamageRegion
      clear_color : Color
      cache_epoch : Int
    } derive(Eq, ToJson, 
    Debug    )

    DrawFrame::new

    source
    fn DrawFrame::new(commands~ : Array[DrawCommand], platform_views? : Array[PlatformViewPlacement], damage~ : DamageRegion, clear_color? : Color, cache_epoch? : Int) -> DrawFrame

    Easing

    source
    pub(all) enum Easing {
      Linear
      EaseIn
      EaseOut
      EaseInOut
    } derive(Eq, ToJson, 
    Debug    )

    Easing::sample

    source
    fn Easing::sample(self : Easing, progress : Double) -> Double

    Effect

    source
    pub(all) enum Effect[Msg] {
      NoEffect
      Batch(Array[Effect[Msg]])
      Send(Msg)
      Dispatch(((Msg) -> Unit) -> Unit)
      Run(EffectDescriptor, ((Msg) -> Unit) -> Unit)
      Task(EffectDescriptor, ((Msg) -> Unit) -> () -> Unit?)
    }

    Effect::batch

    source
    fn[Msg] Effect::batch(effects : Array[Effect[Msg]]) -> Effect[Msg]

    Effect::dispatch

    source
    fn[Msg] Effect::dispatch(run : ((Msg) -> Unit) -> Unit) -> Effect[Msg]

    Effect::host_service

    source
    fn[Msg] Effect::host_service(key~ : String, run~ : ((Msg) -> Unit) -> Unit, label? : String) -> Effect[Msg]

    Effect::map

    source
    fn[Msg, NextMsg] Effect::map(self : Effect[Msg], map : (Msg) -> NextMsg) -> Effect[NextMsg]

    Effect::none

    source
    fn[Msg] Effect::none() -> Effect[Msg]

    Effect::run

    source
    fn[Msg] Effect::run(key~ : String, run~ : ((Msg) -> Unit) -> Unit, kind? : String, label? : String) -> Effect[Msg]

    Effect::runtime_visit

    source
    fn[Msg] Effect::runtime_visit(self : Effect[Msg], send : (Msg) -> Unit, dispatch_effect : (((Msg) -> Unit) -> Unit) -> Unit, run_effect : (EffectDescriptor, ((Msg) -> Unit) -> Unit) -> Unit, start_task : (EffectDescriptor, ((Msg) -> Unit) -> () -> Unit?) -> Unit) -> Unit

    Effect::send

    source
    fn[Msg] Effect::send(message : Msg) -> Effect[Msg]

    Effect::service_task

    source
    fn[Msg] Effect::service_task(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, label? : String) -> Effect[Msg]

    Effect::task

    source
    fn[Msg] Effect::task(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, kind? : String, label? : String) -> Effect[Msg]

    EffectDescriptor

    source
    type EffectDescriptor derive(Eq, ToJson, 
    Debug    )

    EffectDescriptor::key

    source
    fn EffectDescriptor::key(self : EffectDescriptor) -> String

    EffectDescriptor::kind

    source
    fn EffectDescriptor::kind(self : EffectDescriptor) -> String

    EffectDescriptor::label

    source
    fn EffectDescriptor::label(self : EffectDescriptor) -> String

    ElementId

    source

    ElementId::new

    source
    fn ElementId::new(value : Int) -> ElementId

    ElementId::value

    source
    fn ElementId::value(self : ElementId) -> Int

    Environment

    source
    pub(all) struct Environment {
      theme_spec : ThemeSpec
      system_scheme : ColorScheme
      theme : Theme
      scale_factor : Double
      text_scale : Double
      locale : String
      layout_direction : LayoutDirection
      accessibility_contrast : AccessibilityContrast
      reduced_motion : Bool
      content_size_category : ContentSizeCategory
      enabled : Bool
    } derive(Eq, ToJson, 
    Debug    )

    Runtime environment snapshot. Carries the user's theme_spec (intent), the current system_scheme (host-reported), and the resolved theme derived from both. Changing system_scheme rebuilds the full theme via with_system_scheme; the legacy with_color_scheme (which only flipped a flag and left the palette stale) is removed.

    Environment::color_scheme

    source
    fn Environment::color_scheme(self : Environment) -> ColorScheme

    Read the effective color scheme (from the resolved theme). Kept as a convenience accessor so callers do not have to reach into theme.scheme.

    Environment::neutral

    source
    fn Environment::neutral() -> Environment

    Neutral environment: Minimal theme following a light system scheme, standard density/contrast, full motion. The theme_spec records the intent so a later ThemeChanged(Dark) event rebuilds the full dark theme instead of leaving a stale light palette.

    Environment::revision_fingerprint

    source
    fn Environment::revision_fingerprint(self : Environment) -> String

    Content fingerprint for an Environment, used by View::environment modifier revision. Combines the theme fingerprint with the a11y/motion fields that change paint output so a state-layer or reduced-motion change is not swallowed by reconcile.

    Environment::with_accessibility_contrast

    source
    fn Environment::with_accessibility_contrast(self : Environment, accessibility_contrast : AccessibilityContrast) -> Environment

    Update accessibility contrast. Also updates theme_spec.contrast so a subsequent system-scheme change re-resolves with the new contrast.

    Environment::with_content_size_category

    source
    fn Environment::with_content_size_category(self : Environment, content_size_category : ContentSizeCategory) -> Environment

    Environment::with_enabled

    source
    fn Environment::with_enabled(self : Environment, enabled : Bool) -> Environment

    Environment::with_layout_direction

    source
    fn Environment::with_layout_direction(self : Environment, layout_direction : LayoutDirection) -> Environment

    Environment::with_locale

    source
    fn Environment::with_locale(self : Environment, locale : String) -> Environment

    Environment::with_reduced_motion

    source
    fn Environment::with_reduced_motion(self : Environment, reduced_motion : Bool) -> Environment

    Update reduced motion. Also updates theme_spec.reduced_motion so a subsequent re-resolve zeroes motion durations.

    Environment::with_scale_factor

    source
    fn Environment::with_scale_factor(self : Environment, scale_factor : Double) -> Environment

    Environment::with_system_scheme

    source
    fn Environment::with_system_scheme(self : Environment, system_scheme : ColorScheme) -> Environment

    Replace the system color scheme and rebuild the full theme from theme_spec. This is the host-facing entry point: a ThemeChanged(Dark) event calls this so the palette/surfaces/shadows actually switch to dark, fixing the old bug where only the scheme flag flipped.

    Environment::with_text_scale

    source
    fn Environment::with_text_scale(self : Environment, text_scale : Double) -> Environment

    Environment::with_theme

    source
    fn Environment::with_theme(self : Environment, theme : Theme) -> Environment

    Replace the theme. Also updates system_scheme to match the theme's scheme so the two stay consistent. Use with_theme_spec + with_system_scheme for the resolver-driven path; this helper is for callers that already have a fully resolved Theme (e.g. a branded addon that built one directly).

    Environment::with_theme_spec

    source
    fn Environment::with_theme_spec(self : Environment, theme_spec : ThemeSpec) -> Environment

    Replace the theme spec and rebuild the full theme against the current system scheme. App code calls this when the user picks a new preset, density, or contrast.

    FeedbackTheme

    source
    pub(all) struct FeedbackTheme {
      neutral : ToneTokens
      info : ToneTokens
      success : ToneTokens
      warning : ToneTokens
      danger : ToneTokens
      radius : Double
      padding : Double
    } derive(Eq, ToJson, 
    Debug    )

    FilterEffect

    source
    pub(all) enum FilterEffect {
      Blur(Double)
      Saturate(Double)
      Brightness(Double)
      Contrast(Double)
      ColorMatrix(Array[Double])
    } derive(Eq, ToJson, 
    Debug    )

    FilterEffect::blur

    source
    fn FilterEffect::blur(radius : Double) -> FilterEffect

    FocusScope

    source
    type FocusScope derive(Eq)

    FocusScope::command_target

    source
    fn FocusScope::command_target(self : FocusScope, intent : CommandIntent) -> String?

    FocusScope::first_focusable

    source
    fn FocusScope::first_focusable(self : FocusScope) -> String?

    FocusScope::focus_target_or_first

    source
    fn FocusScope::focus_target_or_first(self : FocusScope, target : String?) -> String?

    FocusScope::last_focusable

    source
    fn FocusScope::last_focusable(self : FocusScope) -> String?

    FocusScope::new

    source
    fn FocusScope::new(items~ : Array[FocusScopeItem], current? : String?, wrap? : Bool, default_action? : String, dismiss_action? : String) -> FocusScope

    FocusScope::next

    source
    fn FocusScope::next(self : FocusScope) -> String?

    FocusScope::previous

    source
    fn FocusScope::previous(self : FocusScope) -> String?

    FocusScope::traverse

    source
    fn FocusScope::traverse(self : FocusScope, direction : FocusTraversalDirection) -> String?

    FocusScopeItem

    source
    type FocusScopeItem derive(Eq)

    FocusScopeItem::new

    source
    fn FocusScopeItem::new(id~ : String, enabled? : Bool, focusable? : Bool) -> FocusScopeItem

    FocusState

    source
    pub struct FocusState {
      key_slot : State[String?]
    }

    FocusState::binding

    source
    fn FocusState::binding(self : FocusState) -> Binding[String?]

    FocusState::clear

    source
    fn FocusState::clear(self : FocusState) -> Unit

    FocusState::focus

    source
    fn FocusState::focus(self : FocusState, key : String) -> Unit

    FocusState::focused_key

    source
    fn FocusState::focused_key(self : FocusState) -> String?

    FocusState::new

    source
    fn FocusState::new(key? : String?) -> FocusState

    FocusTraversalDirection

    source
    pub(all) enum FocusTraversalDirection {
      Next
      Previous
    } derive(Eq, ToJson, 
    Debug    )

    FontFamily

    source
    pub(all) enum FontFamily {
      Name(String)
      SystemUi
      UiSansSerif
      UiSerif
      UiMonospace
      SansSerif
      Serif
      Monospace
      Emoji
      Math
      FangSong
    } derive(Eq, ToJson, 
    Debug    )

    FontFamily::css_name

    source
    fn FontFamily::css_name(self : FontFamily) -> String

    FontFamily::css_token

    source
    fn FontFamily::css_token(self : FontFamily) -> String

    FontFamilyStack

    source
    pub(all) struct FontFamilyStack {
      families : Array[FontFamily]
    } derive(Eq, ToJson, 
    Debug    )

    FontFamilyStack::css

    source
    fn FontFamilyStack::css(self : FontFamilyStack) -> String

    FontFamilyStack::monospace

    source
    fn FontFamilyStack::monospace() -> FontFamilyStack

    FontFamilyStack::named

    source
    fn FontFamilyStack::named(name : String) -> FontFamilyStack

    FontFamilyStack::new

    source

    FontFamilyStack::sans_serif

    source
    fn FontFamilyStack::sans_serif() -> FontFamilyStack

    FontFamilyStack::serif

    source

    FontFamilyStack::system_ui

    source
    fn FontFamilyStack::system_ui() -> FontFamilyStack

    FontFamilyStack::with_fallback

    source
    fn FontFamilyStack::with_fallback(self : FontFamilyStack, family : FontFamily) -> FontFamilyStack

    FontSpec

    source
    pub(all) struct FontSpec {
      families : FontFamilyStack
      size : Double
      weight : Int
      style : FontStyle
    } derive(Eq, ToJson, 
    Debug    )

    FontSpec::css_family

    source
    fn FontSpec::css_family(self : FontSpec) -> String

    FontSpec::css_style

    source
    fn FontSpec::css_style(self : FontSpec) -> String

    FontSpec::new

    source
    fn FontSpec::new(families? : FontFamilyStack, size? : Double, weight? : Int, style? : FontStyle) -> FontSpec

    FontStyle

    source
    pub(all) enum FontStyle {
      Normal
      Italic
    } derive(Eq, ToJson, 
    Debug    )

    FormValidationTheme

    source
    pub(all) struct FormValidationTheme {
      foreground : Color
      background : Color
      border : Color
      radius : Double
      padding : Double
    } derive(Eq, ToJson, 
    Debug    )

    Frame

    source
    pub(all) struct Frame {
      time_ms : Double
      delta_ms : Double
    } derive(Eq, ToJson, 
    Debug    )

    Frame::new

    source
    fn Frame::new(time_ms~ : Double, delta_ms~ : Double) -> Frame

    ImageFit

    source
    pub(all) enum ImageFit {
      Contain
      Cover
      Stretch
      ScaleDown
      FitWidth
      FitHeight
    } derive(Eq, ToJson, 
    Debug    )

    ImageRun

    source
    pub(all) struct ImageRun {
      source : String
      frame : Rect
      opacity : Double
      fit : ImageFit
    } derive(Eq, ToJson, 
    Debug    )

    Insets

    source
    pub(all) struct Insets {
      top : Double
      right : Double
      bottom : Double
      left : Double
    } derive(Eq, ToJson, 
    Debug    )

    Insets::all

    source
    fn Insets::all(value : Double) -> Insets

    Insets::symmetric

    source
    fn Insets::symmetric(horizontal? : Double, vertical? : Double) -> Insets

    InteractionState

    source
    pub(all) enum InteractionState {
      Normal
      Hovered
      Pressed
      Focused
      Disabled
      Selected
      Invalid
    } derive(Eq, ToJson, 
    Debug    )

    Control interaction state for token resolution. This is the token-layer state enum used to select a ControlStateStyle from a component theme. It is distinct from the runtime ButtonState (a three-state gesture enum): InteractionState covers the union of states every component theme needs to resolve (normal/hovered/pressed/focused/disabled/selected/invalid), and individual controls only pass the subset they support.

    Key

    source
    type Key derive(Eq)

    Key::new

    source
    fn Key::new(value : String) -> Key

    Key::value

    source
    fn Key::value(self : Key) -> String

    KeyModifiers

    source
    pub(all) struct KeyModifiers {
      shift : Bool
      control : Bool
      alt : Bool
      meta : Bool
    } derive(Eq, ToJson, 
    Debug    )

    KeyModifiers::new

    source
    fn KeyModifiers::new(shift? : Bool, control? : Bool, alt? : Bool, meta? : Bool) -> KeyModifiers

    KeyModifiers::none

    source

    KeyboardEvent

    source
    pub(all) struct KeyboardEvent {
      key : String
      text : String?
      pressed : Bool
      repeat : Bool
      modifiers : KeyModifiers
    } derive(Eq, ToJson, 
    Debug    )

    KeyboardEvent::new

    source
    fn KeyboardEvent::new(key~ : String, pressed? : Bool, text? : String?, repeat? : Bool, modifiers? : KeyModifiers) -> KeyboardEvent

    KeyboardShortcut

    source
    pub(all) struct KeyboardShortcut {
      key : String
      modifiers : KeyModifiers
    } derive(Eq, ToJson, 
    Debug    )

    KeyboardShortcut::display_label

    source
    fn KeyboardShortcut::display_label(self : KeyboardShortcut) -> String

    KeyboardShortcut::matches

    source
    fn KeyboardShortcut::matches(self : KeyboardShortcut, event : KeyboardEvent) -> Bool

    KeyboardShortcut::new

    source
    fn KeyboardShortcut::new(key~ : String, modifiers? : KeyModifiers) -> KeyboardShortcut

    LayerMask

    source
    pub(all) enum LayerMask {
      NoMask
      RectMask(Rect)
      RoundedMask(RoundedRect)
    } derive(Eq, ToJson, 
    Debug    )

    LayerSpec

    source
    pub(all) struct LayerSpec {
      opacity : Double
      blend_mode : BlendMode
      mask : LayerMask
      offscreen : Bool
    } derive(Eq, ToJson, 
    Debug    )

    LayerSpec::new

    source
    fn LayerSpec::new(opacity? : Double, blend_mode? : BlendMode, mask? : LayerMask, offscreen? : Bool) -> LayerSpec

    LayoutDirection

    source
    pub(all) enum LayoutDirection {
      LeftToRight
      RightToLeft
    } derive(Eq, ToJson, 
    Debug    )

    LayoutResult

    source
    pub(all) struct LayoutResult {
      frame : Rect
      children : Array[LayoutResult]
    } derive(Eq, ToJson, 
    Debug    )

    Recursive layout tree produced by the layout pass. Unlike ViewLayoutResult (a single node's measured size + child frames), LayoutResult is the fully-nested tree emitted by AppRuntime::layout.

    LinearGradientSpec

    source
    pub(all) struct LinearGradientSpec {
      start : Point
      end : Point
      start_color : Color
      end_color : Color
    } derive(Eq, ToJson, 
    Debug    )

    LinearGradientSpec::new

    source
    fn LinearGradientSpec::new(start~ : Point, end~ : Point, start_color~ : Color, end_color~ : Color) -> LinearGradientSpec

    MainAxisAlignment

    source
    pub(all) enum MainAxisAlignment {
      MainStart
      MainCenter
      MainEnd
      SpaceBetween
      SpaceAround
      SpaceEvenly
    } derive(Eq, ToJson, 
    Debug    )

    MotionScale

    source
    pub(all) struct MotionScale {
      fast_ms : Double
      normal_ms : Double
      slow_ms : Double
      easing : Easing
    } derive(Eq, ToJson, 
    Debug    )

    MotionScale::default

    source
    fn MotionScale::default() -> MotionScale

    pub struct NavigationState {
      stack_slot : State[Array[String]]
    }

    fn NavigationState::binding(self : NavigationState) -> Binding[Array[String]]

    fn NavigationState::current(self : NavigationState) -> String

    fn NavigationState::new(initial? : String) -> NavigationState

    fn NavigationState::pop(self : NavigationState) -> Bool

    fn NavigationState::push(self : NavigationState, route : String) -> Unit

    fn NavigationState::replace(self : NavigationState, route : String) -> Unit

    fn NavigationState::stack(self : NavigationState) -> Array[String]

    PathSpec

    source
    pub(all) struct PathSpec {
      verbs : Array[PathVerb]
      fill : Brush?
      stroke : Brush?
      stroke_width : Double
    } derive(Eq, ToJson, 
    Debug    )

    PathSpec::bounds

    source
    fn PathSpec::bounds(self : PathSpec) -> Rect?

    PathSpec::new

    source
    fn PathSpec::new(verbs~ : Array[PathVerb], fill? : Brush?, stroke? : Brush?, stroke_width? : Double) -> PathSpec

    PathVerb

    source
    pub(all) enum PathVerb {
      MoveTo(Point)
      LineTo(Point)
      QuadTo(Point, Point)
      CubicTo(Point, Point, Point)
      Close
    } derive(Eq, ToJson, 
    Debug    )

    PickerTheme

    source
    pub(all) struct PickerTheme {
      font : FontSpec
      foreground : Color
      background : Brush
      radius : Double
      popup_max_height : Double
    } derive(Eq, ToJson, 
    Debug    )

    PlatformViewEvent

    source
    pub(all) enum PlatformViewEvent {
      Named(name~ : String, value~ : String, detail~ : String, flag~ : Bool)
    } derive(Eq, ToJson, 
    Debug    )

    PlatformViewPlacement

    source
    pub(all) struct PlatformViewPlacement {
      id : String
      kind : String
      frame : Rect
      clip : Rect?
      properties : Array[PlatformViewProperty]
    } derive(Eq, ToJson, 
    Debug    )

    PlatformViewPlacement::new

    source
    fn PlatformViewPlacement::new(id~ : String, kind~ : String, frame~ : Rect, clip? : Rect?, properties? : Array[PlatformViewProperty]) -> PlatformViewPlacement

    PlatformViewPlacement::property

    source
    fn PlatformViewPlacement::property(self : PlatformViewPlacement, key : String) -> String?

    PlatformViewPlacement::property_or

    source
    fn PlatformViewPlacement::property_or(self : PlatformViewPlacement, key : String, default : String) -> String

    PlatformViewProperty

    source
    pub(all) struct PlatformViewProperty {
      key : String
      value : String
    } derive(Eq, ToJson, 
    Debug    )

    PlatformViewProperty::new

    source
    fn PlatformViewProperty::new(key~ : String, value~ : String) -> PlatformViewProperty

    Point

    source
    pub(all) struct Point {
      x : Double
      y : Double
    } derive(Eq, ToJson, 
    Debug    )

    Point::new

    source
    fn Point::new(x~ : Double, y~ : Double) -> Point

    PointerEvent

    source
    pub(all) struct PointerEvent {
      position : Point
      phase : PointerPhase
      button : Int
      wheel_delta : Point
      time_ms : Double
      modifiers : KeyModifiers
    } derive(Eq, ToJson, 
    Debug    )

    PointerEvent::new

    source
    fn PointerEvent::new(position~ : Point, phase~ : PointerPhase, button? : Int, wheel_delta? : Point, time_ms? : Double, modifiers? : KeyModifiers) -> PointerEvent

    PointerPhase

    source
    pub(all) enum PointerPhase {
      Move
      Down
      Up
      Cancel
      Exit
    } derive(Eq, ToJson, 
    Debug    )

    Pointer interaction phase. Move/Down/Up/Cancel are produced by host backends from raw input. Exit is a synthetic, runtime-only phase: the runtime emits it to the previously hovered element when the pointer leaves its bounds (host backends never produce it). Views use it to clear hover state that they otherwise could not, because a normal Move outside the element is never delivered to it by hit-testing.

    Program

    source
    type Program[Model, Msg]

    Program::new

    source
    fn[Model, Msg] Program::new(init~ : () -> (Model, Effect[Msg]), update~ : (Model, Msg) -> (Model, Effect[Msg]), view~ : (Model) -> View[Msg], subscriptions? : (Model) -> Subscription[Msg]) -> Program[Model, Msg]

    Program::new_with_environment

    source
    fn[Model, Msg] Program::new_with_environment(init~ : () -> (Model, Effect[Msg]), update~ : (Model, Msg) -> (Model, Effect[Msg]), view~ : (Model, ViewEnvironment) -> View[Msg], subscriptions? : (Model) -> Subscription[Msg]) -> Program[Model, Msg]

    Program::runtime_init

    source
    fn[Model, Msg] Program::runtime_init(self : Program[Model, Msg]) -> (Model, Effect[Msg])

    Program::runtime_subscriptions

    source
    fn[Model, Msg] Program::runtime_subscriptions(self : Program[Model, Msg], model : Model) -> Subscription[Msg]

    Program::runtime_update

    source
    fn[Model, Msg] Program::runtime_update(self : Program[Model, Msg], model : Model, message : Msg) -> (Model, Effect[Msg])

    Program::runtime_view

    source
    fn[Model, Msg] Program::runtime_view(self : Program[Model, Msg], model : Model, environment : ViewEnvironment) -> View[Msg]

    Program::simple

    source
    fn[Model, Msg] Program::simple(init~ : Model, update~ : (Model, Msg) -> Model, view~ : (Model) -> View[Msg], subscriptions? : (Model) -> Subscription[Msg]) -> Program[Model, Msg]

    Program::simple_with_environment

    source
    fn[Model, Msg] Program::simple_with_environment(init~ : Model, update~ : (Model, Msg) -> Model, view~ : (Model, ViewEnvironment) -> View[Msg], subscriptions? : (Model) -> Subscription[Msg]) -> Program[Model, Msg]

    ProgressTheme

    source
    pub(all) struct ProgressTheme {
      foreground : Color
      background : Color
      radius : Double
    } derive(Eq, ToJson, 
    Debug    )

    RadialGradientSpec

    source
    pub(all) struct RadialGradientSpec {
      center : Point
      radius : Double
      center_color : Color
      edge_color : Color
    } derive(Eq, ToJson, 
    Debug    )

    RadialGradientSpec::new

    source
    fn RadialGradientSpec::new(center~ : Point, radius~ : Double, center_color~ : Color, edge_color~ : Color) -> RadialGradientSpec

    RadiusScale

    source
    pub(all) struct RadiusScale {
      sm : Double
      md : Double
      lg : Double
      pill : Double
    } derive(Eq, ToJson, 
    Debug    )

    RadiusScale::default

    source
    fn RadiusScale::default() -> RadiusScale

    Rect

    source
    pub(all) struct Rect {
      origin : Point
      size : Size
    } derive(Eq, ToJson, 
    Debug    )

    Rect::area

    source
    fn Rect::area(self : Rect) -> Double

    Rect::clamp_to

    source
    fn Rect::clamp_to(self : Rect, bounds : Rect) -> Rect?

    Rect::contains

    source
    fn Rect::contains(self : Rect, point : Point) -> Bool

    Rect::inflate

    source
    fn Rect::inflate(self : Rect, value : Double) -> Rect

    Rect::inset

    source
    fn Rect::inset(self : Rect, insets : Insets) -> Rect

    Rect::intersection

    source
    fn Rect::intersection(self : Rect, other : Rect) -> Rect?

    Rect::is_empty

    source
    fn Rect::is_empty(self : Rect) -> Bool

    Rect::max_x

    source
    fn Rect::max_x(self : Rect) -> Double

    Rect::max_y

    source
    fn Rect::max_y(self : Rect) -> Double

    Rect::new

    source
    fn Rect::new(x~ : Double, y~ : Double, width~ : Double, height~ : Double) -> Rect

    Rect::offset

    source
    fn Rect::offset(self : Rect, dx? : Double, dy? : Double) -> Rect

    Rect::union

    source
    fn Rect::union(self : Rect, other : Rect) -> Rect

    RedrawReason

    source
    pub(all) enum RedrawReason {
      Initial
      Input
      Resize
      Explicit
    } derive(Eq, ToJson, 
    Debug    )

    RoundedRect

    source
    pub(all) struct RoundedRect {
      rect : Rect
      radius : Double
    } derive(Eq, ToJson, 
    Debug    )

    RoundedRect::new

    source
    fn RoundedRect::new(rect~ : Rect, radius? : Double) -> RoundedRect

    SaveableCodec

    source
    type SaveableCodec[T]

    SaveableCodec::bool

    source
    fn SaveableCodec::bool() -> SaveableCodec[Bool]

    SaveableCodec::decode_value

    source
    fn[T] SaveableCodec::decode_value(self : SaveableCodec[T], payload : String) -> T?

    SaveableCodec::encode_value

    source
    fn[T] SaveableCodec::encode_value(self : SaveableCodec[T], value : T) -> String

    SaveableCodec::int

    source
    fn SaveableCodec::int() -> SaveableCodec[Int]

    SaveableCodec::new

    source
    fn[T] SaveableCodec::new(encode~ : (T) -> String, decode~ : (String) -> T?) -> SaveableCodec[T]

    SaveableCodec::string

    source
    fn SaveableCodec::string() -> SaveableCodec[String]

    SaveableStateSnapshot

    source
    type SaveableStateSnapshot derive(Eq, ToJson, 
    Debug    )

    SaveableStateStore

    source
    type SaveableStateStore

    SaveableStateStore::get

    source
    fn[T] SaveableStateStore::get(self : SaveableStateStore, key : String, codec : SaveableCodec[T]) -> T?

    SaveableStateStore::get_bool

    source
    fn SaveableStateStore::get_bool(self : SaveableStateStore, key : String) -> Bool?

    SaveableStateStore::get_int

    source
    fn SaveableStateStore::get_int(self : SaveableStateStore, key : String) -> Int?

    SaveableStateStore::get_string

    source
    fn SaveableStateStore::get_string(self : SaveableStateStore, key : String) -> String?

    SaveableStateStore::new

    source

    SaveableStateStore::remove

    source
    fn SaveableStateStore::remove(self : SaveableStateStore, key : String) -> Unit

    SaveableStateStore::restore

    source
    fn SaveableStateStore::restore(self : SaveableStateStore, snapshot : SaveableStateSnapshot) -> Unit

    SaveableStateStore::set

    source
    fn[T] SaveableStateStore::set(self : SaveableStateStore, key : String, value : T, codec : SaveableCodec[T]) -> Unit

    SaveableStateStore::set_bool

    source
    fn SaveableStateStore::set_bool(self : SaveableStateStore, key : String, value : Bool) -> Unit

    SaveableStateStore::set_int

    source
    fn SaveableStateStore::set_int(self : SaveableStateStore, key : String, value : Int) -> Unit

    SaveableStateStore::set_string

    source
    fn SaveableStateStore::set_string(self : SaveableStateStore, key : String, value : String) -> Unit

    SaveableStateStore::snapshot

    source

    ScrollAlignment

    source
    pub(all) enum ScrollAlignment {
      Start
      Center
      End
      Nearest
    } derive(Eq, ToJson, 
    Debug    )

    ScrollState

    source
    pub struct ScrollState {
      offset_slot : State[Point]
      smooth_target : State[Point?]
      smooth_start : State[Point?]
      smooth_start_time_ms : State[Double?]
      smooth_duration_ms : State[Double?]
    }

    ScrollState::binding

    source
    fn ScrollState::binding(self : ScrollState) -> Binding[Point]

    ScrollState::is_smooth_scrolling

    source
    fn ScrollState::is_smooth_scrolling(self : ScrollState) -> Bool

    ScrollState::new

    source
    fn ScrollState::new(offset? : Point) -> ScrollState

    ScrollState::offset

    source
    fn ScrollState::offset(self : ScrollState) -> Point

    ScrollState::scroll_to

    source
    fn ScrollState::scroll_to(self : ScrollState, x~ : Double, y~ : Double) -> Unit

    ScrollState::set_offset

    source
    fn ScrollState::set_offset(self : ScrollState, offset : Point) -> Unit

    ScrollState::smooth_scroll_to

    source
    fn ScrollState::smooth_scroll_to(self : ScrollState, x~ : Double, y~ : Double, duration_ms? : Double) -> Unit

    ScrollState::tick

    source
    fn ScrollState::tick(self : ScrollState, time_ms : Double) -> Unit

    SemanticsAction

    source
    pub(all) enum SemanticsAction {
      Activate
      Focus
      SetText
      Submit
      Scroll
      Select
      Expand
      Collapse
      Dismiss
    } derive(Eq, ToJson, 
    Debug    )

    SemanticsNode

    source
    pub(all) struct SemanticsNode {
      element_id : ElementId
      role : SemanticsRole
      level : Int?
      url : String
      label : String
      value : String
      description : String
      state : SemanticsState
      actions : Array[SemanticsAction]
      focus_order : Int?
      frame : Rect
      children : Array[SemanticsNode]
    } derive(Eq, ToJson, 
    Debug    )

    SemanticsRole

    source
    pub(all) enum SemanticsRole {
      None
      Text
      Link
      Heading
      Navigation
      Main
      Button
      Checkbox
      TextField
      List
      ListItem
      Grid
      ScrollView
      Switch
      Radio
      Slider
      Progress
      Tab
      Dialog
      Tooltip
      Menu
      ButtonGroup
      Form
      FormField
      Tree
      TreeItem
      Group
      WebView
    } derive(Eq, ToJson, 
    Debug    )

    SemanticsState

    source
    pub(all) struct SemanticsState {
      focused : Bool
      disabled : Bool
      selected : Bool
      pressed : Bool
      checked : Bool
      expanded : Bool
      invalid : Bool
      required : Bool
    } derive(Eq, ToJson, 
    Debug    )

    SemanticsState::default

    source

    ShaderEffectSpec

    source
    pub(all) struct ShaderEffectSpec {
      name : String
      frame : Rect
      uniforms : Array[Double]
      fallback : Brush
    } derive(Eq, ToJson, 
    Debug    )

    ShaderEffectSpec::new

    source
    fn ShaderEffectSpec::new(name~ : String, frame~ : Rect, uniforms? : Array[Double], fallback? : Brush) -> ShaderEffectSpec

    ShadowScale

    source
    pub(all) struct ShadowScale {
      sm : ShadowStyle
      md : ShadowStyle
      lg : ShadowStyle
    } derive(Eq, ToJson, 
    Debug    )

    ShadowScale::default

    source
    fn ShadowScale::default(scheme? : ColorScheme) -> ShadowScale

    ShadowSpec

    source
    pub(all) struct ShadowSpec {
      rect : RoundedRect
      color : Color
      offset : Point
      blur_radius : Double
      spread : Double
    } derive(Eq, ToJson, 
    Debug    )

    ShadowSpec::new

    source
    fn ShadowSpec::new(rect~ : RoundedRect, color~ : Color, offset? : Point, blur_radius? : Double, spread? : Double) -> ShadowSpec

    ShadowStyle

    source
    pub(all) struct ShadowStyle {
      color : Color
      offset : Point
      blur_radius : Double
      spread : Double
    } derive(Eq, ToJson, 
    Debug    )

    ShadowStyle::new

    source
    fn ShadowStyle::new(color~ : Color, offset? : Point, blur_radius? : Double, spread? : Double) -> ShadowStyle

    Size

    source
    pub(all) struct Size {
      width : Double
      height : Double
    } derive(Eq, ToJson, 
    Debug    )

    Size::clamp

    source
    fn Size::clamp(self : Size, constraints : Constraints) -> Size

    Size::inflate

    source
    fn Size::inflate(self : Size, insets : Insets) -> Size

    Size::new

    source
    fn Size::new(width~ : Double, height~ : Double) -> Size

    SliderTheme

    source
    pub(all) struct SliderTheme {
      foreground : Color
      background : Color
      thumb_color : Color
      track_height : Double
      thumb_size : Double
      radius : Double
      thumb_shape : ThumbShape
    } derive(Eq, ToJson, 
    Debug    )

    SpacingScale

    source
    pub(all) struct SpacingScale {
      xs : Double
      sm : Double
      md : Double
      lg : Double
      xl : Double
    } derive(Eq, ToJson, 
    Debug    )

    SpacingScale::default

    source
    fn SpacingScale::default() -> SpacingScale

    State

    source
    pub struct State[T] {
      // private fields
    }

    State::binding

    source
    fn[T] State::binding(self : State[T]) -> Binding[T]

    State::derived

    source
    fn[T, U] State::derived(self : State[T], project : (T) -> U) -> DerivedState[U]

    State::get

    source
    fn[T] State::get(self : State[T]) -> T

    State::new

    source
    fn[T] State::new(value : T) -> State[T]

    State::set

    source
    fn[T] State::set(self : State[T], value : T) -> Unit

    State::subscribe

    source
    fn[T] State::subscribe(self : State[T], callback : () -> Unit) -> StateSubscription

    State::update

    source
    fn[T] State::update(self : State[T], f : (T) -> T raise?) -> Unit raise?

    State::version

    source
    fn[T] State::version(self : State[T]) -> Int

    StateLayerTokens

    source
    pub(all) struct StateLayerTokens {
      color : Color
      hover_alpha : Double
      focus_alpha : Double
      pressed_alpha : Double
      dragged_alpha : Double
      selected_alpha : Double
      disabled_alpha : Double
    } derive(Eq, ToJson, 
    Debug    )

    State-layer tokens. Shared by all controls that use the state-layer model (buttons, list rows, menu items): a translucent overlay of color is blended onto the base background at hover_alpha/focus_alpha/... to produce interaction feedback without per-variant color shifts.

    StateListener

    source
    type StateListener

    StateSlot

    source
    type StateSlot[T]

    StateSubscription

    source
    pub struct StateSubscription {
      // private fields
    }

    StateSubscription::cancel

    source
    fn StateSubscription::cancel(self : StateSubscription) -> Unit

    StateSubscription::is_active

    source
    fn StateSubscription::is_active(self : StateSubscription) -> Bool

    Subscription

    source
    pub struct Subscription[Msg] {
      // private fields
    }

    Subscription::animation_tick

    source
    fn[Msg] Subscription::animation_tick(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, label? : String) -> Subscription[Msg]

    Subscription::batch

    source
    fn[Msg] Subscription::batch(subscriptions : Array[Subscription[Msg]]) -> Subscription[Msg]

    Subscription::descriptors

    source
    fn[Msg] Subscription::descriptors(self : Subscription[Msg]) -> Array[SubscriptionDescriptor]

    Subscription::host_event

    source
    fn[Msg] Subscription::host_event(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, label? : String) -> Subscription[Msg]

    Subscription::listen

    source
    fn[Msg] Subscription::listen(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, kind? : String, label? : String) -> Subscription[Msg]

    Subscription::map

    source
    fn[Msg, NextMsg] Subscription::map(self : Subscription[Msg], map : (Msg) -> NextMsg) -> Subscription[NextMsg]

    Subscription::none

    source
    fn[Msg] Subscription::none() -> Subscription[Msg]

    Subscription::route_event

    source
    fn[Msg] Subscription::route_event(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, label? : String) -> Subscription[Msg]

    Subscription::run

    source
    fn[Msg] Subscription::run(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, kind? : String, label? : String) -> Subscription[Msg]

    Subscription::runtime_sources

    source
    fn[Msg] Subscription::runtime_sources(self : Subscription[Msg]) -> Array[SubscriptionRuntimeSource[Msg]]

    Subscription::runtime_visit

    source
    fn[Msg] Subscription::runtime_visit(self : Subscription[Msg], none : (Int) -> Unit, batch : (Int, Int) -> Unit, source : (Int, SubscriptionDescriptor) -> Unit) -> Unit

    Subscription::service_completion

    source
    fn[Msg] Subscription::service_completion(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, label? : String) -> Subscription[Msg]

    Subscription::timer

    source
    fn[Msg] Subscription::timer(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, label? : String) -> Subscription[Msg]

    Subscription::window_event

    source
    fn[Msg] Subscription::window_event(key~ : String, start~ : ((Msg) -> Unit) -> () -> Unit?, label? : String) -> Subscription[Msg]

    SubscriptionDescriptor

    source
    type SubscriptionDescriptor derive(Eq, ToJson, 
    Debug    )

    SubscriptionDescriptor::key

    source

    SubscriptionDescriptor::kind

    source

    SubscriptionDescriptor::label

    source

    SubscriptionRuntimeSource

    source
    pub struct SubscriptionRuntimeSource[Msg] {
      // private fields
    }

    SubscriptionRuntimeSource::descriptor

    source

    SubscriptionRuntimeSource::key

    source
    fn[Msg] SubscriptionRuntimeSource::key(self : SubscriptionRuntimeSource[Msg]) -> String

    SubscriptionRuntimeSource::kind

    source
    fn[Msg] SubscriptionRuntimeSource::kind(self : SubscriptionRuntimeSource[Msg]) -> String

    SubscriptionRuntimeSource::label

    source
    fn[Msg] SubscriptionRuntimeSource::label(self : SubscriptionRuntimeSource[Msg]) -> String

    SubscriptionRuntimeSource::start

    source
    fn[Msg] SubscriptionRuntimeSource::start(self : SubscriptionRuntimeSource[Msg], dispatch : (Msg) -> Unit) -> () -> Unit?

    SurfaceLevel

    source
    pub(all) enum SurfaceLevel {
      Base
      Raised
      Overlay
    } derive(Eq, ToJson, 
    Debug    )

    SurfaceScale

    source
    pub(all) struct SurfaceScale {
      base : Brush
      raised : Brush
      overlay : Brush
    } derive(Eq, ToJson, 
    Debug    )

    SurfaceScale::default

    source
    fn SurfaceScale::default(palette : ColorPalette, scheme : ColorScheme) -> SurfaceScale

    SurfaceTheme

    source
    pub(all) struct SurfaceTheme {
      base_padding : Double
      raised_padding : Double
      overlay_padding : Double
      base_radius : Double
      raised_radius : Double
      overlay_radius : Double
      base_shadow : ShadowStyle?
      raised_shadow : ShadowStyle?
      overlay_shadow : ShadowStyle?
    } derive(Eq, ToJson, 
    Debug    )

    Per-tier surface component tokens. Fluent 2 cards carry distinct shadows per layer (shadow2/4/28); neutral presets leave them None and rely on the flat surface idiom.

    TextAlign

    source
    pub(all) enum TextAlign {
      TextStart
      TextCenter
      TextEnd
    } derive(Eq, ToJson, 
    Debug    )

    TextCaretDirection

    source
    pub(all) enum TextCaretDirection {
      MoveLeft
      MoveRight
      MoveStart
      MoveEnd
    }

    TextCaretMoveResult

    source
    pub(all) struct TextCaretMoveResult {
      caret : Int
      selection : TextRange?
    }

    TextCommandResult

    source
    pub(all) struct TextCommandResult {
      handled : Bool
      changed : Bool
      clipboard_text : String?
    } derive(Eq, ToJson, 
    Debug    )

    TextCommandResult::handled

    source
    fn TextCommandResult::handled(changed? : Bool, clipboard_text? : String?) -> TextCommandResult

    TextCommandResult::ignored

    source

    TextControlStateContext

    source
    pub(all) struct TextControlStateContext {
      caret : Int
      selection : TextRange?
      text_selection_anchor : Int?
      composition : String?
      composition_cursor : TextRange?
      undo_stack : Array[TextHistoryEntryContext]
      redo_stack : Array[TextHistoryEntryContext]
    } derive(Eq, ToJson, 
    Debug    )

    TextFieldAppearance

    source
    pub(all) enum TextFieldAppearance {
      Filled
      Outline
      Underline
    } derive(Eq, ToJson, 
    Debug    )

    Text-field appearance tier. Fluent 2 ships an underline variant; the neutral default is Outline (full border).

    TextFieldTheme

    source
    pub(all) struct TextFieldTheme {
      normal : ControlStateTokens
      focused : ControlStateTokens
      disabled : ControlStateTokens
      placeholder : Color
      cursor : Color
      font : FontSpec
      appearance : TextFieldAppearance
    } derive(Eq, ToJson, 
    Debug    )

    TextFieldTheme::resolve

    source

    TextHistoryEntryContext

    source
    pub(all) struct TextHistoryEntryContext {
      text : String
      caret : Int
      selection : TextRange?
    } derive(Eq, ToJson, 
    Debug    )

    TextInputEvent

    source
    pub(all) enum TextInputEvent {
      InsertText(String)
      ReplaceText(TextRange, String)
      SetSelection(TextRange)
      CompositionStart
      CompositionUpdate(CompositionUpdate)
      CompositionEnd(String)
      DeleteRange(TextRange)
      DeleteSurrounding(Int, Int)
    } derive(Eq, ToJson, 
    Debug    )

    TextInputState

    source
    pub(all) struct TextInputState {
      focused : Bool
      element_id : ElementId?
      text : String
      caret : Int
      selection : TextRange?
      composition : String?
      composition_cursor : TextRange?
      frame : Rect
      caret_rect : Rect
    } derive(Eq, ToJson, 
    Debug    )

    TextInputState::none

    source

    TextLayoutInput

    source
    pub(all) struct TextLayoutInput {
      text : String
      font : FontSpec
      max_width : Double?
    } derive(Eq, ToJson, 
    Debug    )

    TextLayoutInput::new

    source
    fn TextLayoutInput::new(text~ : String, font~ : FontSpec, max_width? : Double) -> TextLayoutInput

    TextLayoutResult

    source
    pub(all) struct TextLayoutResult {
      size : Size
      baseline : Double
      caret_positions : Array[Double]
    } derive(Eq, ToJson, 
    Debug    )

    TextParagraphHitTestResult

    source
    pub(all) struct TextParagraphHitTestResult {
      offset : Int
      line_index : Int
      caret_rect : Rect
      is_inside : Bool
    } derive(Eq, ToJson, 
    Debug    )

    TextParagraphLayoutMetadata

    source
    pub(all) struct TextParagraphLayoutMetadata {
      text_system_id : String
      paragraph_layout_available : Bool
      line_metrics_available : Bool
      selection_rects_available : Bool
      hit_test_available : Bool
      native_paragraph_ready : Bool
      bidi_visual_order_ready : Bool
    } derive(Eq, ToJson, 
    Debug    )

    TextParagraphLayoutResult

    source
    pub(all) struct TextParagraphLayoutResult {
      text : String
      size : Size
      baseline : Double
      lines : Array[TextParagraphLineMetrics]
      caret_rects : Array[Rect]
      visual_order : TextParagraphVisualOrderMetadata
      metadata : TextParagraphLayoutMetadata
    } derive(Eq, ToJson, 
    Debug    )

    TextParagraphLayoutResult::caret_rect_at

    source
    fn TextParagraphLayoutResult::caret_rect_at(self : TextParagraphLayoutResult, offset : Int) -> Rect

    TextParagraphLayoutResult::hit_test

    source

    TextParagraphLayoutResult::line_count

    source

    TextParagraphLayoutResult::selection_rects

    source

    TextParagraphLineMetrics

    source
    pub(all) struct TextParagraphLineMetrics {
      line_index : Int
      text_range : TextRange
      origin : Point
      size : Size
      baseline : Double
    } derive(Eq, ToJson, 
    Debug    )

    TextParagraphVisualOrderMetadata

    source
    pub(all) struct TextParagraphVisualOrderMetadata {
      logical_text : String
      visual_text : String
      logical_cluster_count : Int
      visual_cluster_count : Int
      segment_count : Int
      glyph_count : Int
      visual_order_differs : Bool
      bidi_visual_order_ready : Bool
    } derive(Eq, ToJson, 
    Debug    )

    TextRange

    source
    pub(all) struct TextRange {
      start : Int
      end : Int
    } derive(Eq, ToJson, 
    Debug    )

    TextRange::collapsed

    source
    fn TextRange::collapsed(index : Int) -> TextRange

    TextRange::is_collapsed

    source
    fn TextRange::is_collapsed(self : TextRange) -> Bool

    TextRange::new

    source
    fn TextRange::new(start~ : Int, end~ : Int) -> TextRange

    TextRange::normalized

    source
    fn TextRange::normalized(self : TextRange) -> TextRange

    TextRun

    source
    pub(all) struct TextRun {
      text : String
      frame : Rect
      font : FontSpec
      color : Color
      align : TextAlign
    } derive(Eq, ToJson, 
    Debug    )

    TextRun::new

    source
    fn TextRun::new(text~ : String, frame~ : Rect, font~ : FontSpec, color~ : Color, align? : TextAlign) -> TextRun

    TextSystem

    source
    pub struct TextSystem {
      id : String
      measure : (TextLayoutInput) -> TextLayoutResult
      paragraph_layout : (TextLayoutInput) -> TextParagraphLayoutResult
      register_font_data : (FontFamily, Bytes) -> Unit
    }

    TextSystem::fallback

    source
    fn TextSystem::fallback() -> TextSystem

    TextSystem::id

    source
    fn TextSystem::id(self : TextSystem) -> String

    TextSystem::layout_paragraph

    source
    fn TextSystem::layout_paragraph(self : TextSystem, input : TextLayoutInput) -> TextParagraphLayoutResult

    TextSystem::measure_text

    source
    fn TextSystem::measure_text(self : TextSystem, input : TextLayoutInput) -> TextLayoutResult

    TextSystem::new

    source
    fn TextSystem::new(id~ : String, measure~ : (TextLayoutInput) -> TextLayoutResult, paragraph_layout? : (TextLayoutInput) -> TextParagraphLayoutResult?, register_font_data? : (FontFamily, Bytes) -> Unit) -> TextSystem

    TextSystem::register_font_data

    source
    fn TextSystem::register_font_data(self : TextSystem, family : FontFamily, data : Bytes) -> Unit

    Theme

    source
    pub(all) struct Theme {
      scheme : ColorScheme
      palette : ColorPalette
      spacing_scale : SpacingScale
      radius_scale : RadiusScale
      typography : TypographyScale
      shadow_scale : ShadowScale
      motion : MotionScale
      surfaces : SurfaceScale
      components : ComponentThemes
    } derive(Eq, ToJson, 
    Debug    )

    Resolved, drawable theme. A Theme is the output of resolve_theme(spec,system_scheme): it carries the full palette, all scale tiers, and a first-class components aggregate. Controls read ctx.environment.theme.components.<control> at paint time; style? on a control constructor is a one-shot override.

    Theme::neutral

    source
    fn Theme::neutral() -> Theme

    Neutral fallback theme. Equivalent to resolving ThemeSpec::default() with a light system scheme. Carries default ComponentThemes derived from the minimal palette.

    Theme::revision_fingerprint

    source
    fn Theme::revision_fingerprint(self : Theme) -> String

    Content fingerprint for a Theme, used by View::theme modifier revision so reconcile can detect a real theme change (different palette/components) instead of treating every .theme(...) wrapper as identical. Covers scheme, the palette colors a paint pass reads, and the button/text-field component tokens that drive control appearance; this is not a full hash, just enough fields to distinguish visually distinct themes.

    Theme::surface_brush

    source
    fn Theme::surface_brush(self : Theme, level : SurfaceLevel) -> Brush

    Theme::with_components

    source
    fn Theme::with_components(self : Theme, components : ComponentThemes) -> Theme

    Theme::with_motion

    source
    fn Theme::with_motion(self : Theme, motion : MotionScale) -> Theme

    Theme::with_palette

    source
    fn Theme::with_palette(self : Theme, palette : ColorPalette) -> Theme

    Theme::with_radius_scale

    source
    fn Theme::with_radius_scale(self : Theme, radius_scale : RadiusScale) -> Theme

    Theme::with_shadow_scale

    source
    fn Theme::with_shadow_scale(self : Theme, shadow_scale : ShadowScale) -> Theme

    Theme::with_spacing_scale

    source
    fn Theme::with_spacing_scale(self : Theme, spacing_scale : SpacingScale) -> Theme

    Theme::with_surfaces

    source
    fn Theme::with_surfaces(self : Theme, surfaces : SurfaceScale) -> Theme

    Theme::with_typography

    source
    fn Theme::with_typography(self : Theme, typography : TypographyScale) -> Theme

    ThemeDensity

    source
    pub(all) enum ThemeDensity {
      Compact
      Standard
      Comfortable
    } derive(Eq, ToJson, 
    Debug    )

    Density tier. Compact shrinks spacing by ~18%, Comfortable grows it by ~18%; Standard is 1.0.

    ThemeDensity::label

    source
    fn ThemeDensity::label(self : ThemeDensity) -> String

    ThemeDensity::multiplier

    source
    fn ThemeDensity::multiplier(self : ThemeDensity) -> Double

    ThemePreset

    source
    pub(all) enum ThemePreset {
      Minimal
      Material
      Carbon
      Primer
      Fluent
    } derive(Eq, ToJson, 
    Debug    )

    Which design-system preset the user selected. core only resolves Minimal itself; branded presets (Material/Carbon/Primer/Fluent) are resolved by the moui_theme addon, which produces a complete @core.Theme (including components). The enum lives in core so Environment can record the user's choice without core depending on the addon.

    ThemeSpec

    source
    pub(all) struct ThemeSpec {
      preset : ThemePreset
      color_mode : ColorMode
      density : ThemeDensity
      contrast : AccessibilityContrast
      seed : Color?
      reduced_motion : Bool
    } derive(Eq, ToJson, 
    Debug    )

    User theme intent. Built by app code (or by a branded addon helper) and stored on Environment.theme_spec; the resolver consumes it whenever the system scheme changes so a ThemeChanged event rebuilds the full theme.

    ThemeSpec::default

    source
    fn ThemeSpec::default() -> ThemeSpec

    Default spec: MoUI Minimal, follow the system, standard density, standard contrast, no seed, full motion.

    ThemeSpec::minimal_dark

    source
    fn ThemeSpec::minimal_dark() -> ThemeSpec

    Minimal-dark spec (forced dark, used by the legacy dark_theme() helper).

    ThemeSpec::minimal_light

    source
    fn ThemeSpec::minimal_light() -> ThemeSpec

    Minimal-light spec (forced light, used by the legacy light_theme() helper).

    ThemeSpec::resolve_scheme

    source
    fn ThemeSpec::resolve_scheme(self : ThemeSpec, system_scheme : ColorScheme) -> ColorScheme

    Resolve the effective color scheme for a spec given the current system scheme. System defers to the platform; Light/Dark override it.

    ThemeSpec::with_color_mode

    source
    fn ThemeSpec::with_color_mode(self : ThemeSpec, color_mode : ColorMode) -> ThemeSpec

    ThemeSpec::with_contrast

    source
    fn ThemeSpec::with_contrast(self : ThemeSpec, contrast : AccessibilityContrast) -> ThemeSpec

    ThemeSpec::with_density

    source
    fn ThemeSpec::with_density(self : ThemeSpec, density : ThemeDensity) -> ThemeSpec

    ThemeSpec::with_preset

    source
    fn ThemeSpec::with_preset(self : ThemeSpec, preset : ThemePreset) -> ThemeSpec

    ThemeSpec::with_reduced_motion

    source
    fn ThemeSpec::with_reduced_motion(self : ThemeSpec, reduced_motion : Bool) -> ThemeSpec

    ThemeSpec::with_seed

    source
    fn ThemeSpec::with_seed(self : ThemeSpec, seed : Color?) -> ThemeSpec

    ThumbShape

    source
    pub(all) enum ThumbShape {
      Rounded
      Circle
    } derive(Eq, ToJson, 
    Debug    )

    Shape of a slider thumb. Rounded uses the theme radius; Circle forces a full circle (thumb radius = thumb_size / 2). Fluent 2 sliders use Circle.

    ThumbShape::label

    source
    fn ThumbShape::label(self : ThumbShape) -> String

    ToneTokens

    source
    pub(all) struct ToneTokens {
      foreground : Color
      background : Color
      border : Color
    } derive(Eq, ToJson, 
    Debug    )

    Transform2D

    source
    pub(all) struct Transform2D {
      a : Double
      b : Double
      c : Double
      d : Double
      tx : Double
      ty : Double
    } derive(Eq, ToJson, 
    Debug    )

    Transform2D::identity

    source
    fn Transform2D::identity() -> Transform2D

    Transform2D::scale

    source
    fn Transform2D::scale(sx~ : Double, sy~ : Double) -> Transform2D

    Transform2D::translation

    source
    fn Transform2D::translation(dx~ : Double, dy~ : Double) -> Transform2D

    TransitionSample

    source
    pub struct TransitionSample {
      progress : Double
      style : TransitionStyle
      present : Bool
    } derive(Eq, ToJson, 
    Debug    )

    TransitionSpec

    source
    pub struct TransitionSpec {
      from : TransitionStyle
      to : TransitionStyle
      duration_ms : Double
      easing : Easing
    } derive(Eq, ToJson, 
    Debug    )

    TransitionSpec::fade

    source
    fn TransitionSpec::fade(from_opacity? : Double, to_opacity? : Double, duration_ms? : Double, easing? : Easing) -> TransitionSpec

    TransitionSpec::new

    source
    fn TransitionSpec::new(from? : TransitionStyle, to? : TransitionStyle, duration_ms? : Double, easing? : Easing) -> TransitionSpec

    TransitionSpec::presence

    source
    fn TransitionSpec::presence(self : TransitionSpec, present~ : Bool, progress~ : Double, reduced_motion? : Bool) -> TransitionSample

    TransitionSpec::sample

    source
    fn TransitionSpec::sample(self : TransitionSpec, progress : Double, reduced_motion? : Bool) -> TransitionSample

    TransitionSpec::sample_elapsed

    source
    fn TransitionSpec::sample_elapsed(self : TransitionSpec, elapsed_ms : Double, reduced_motion? : Bool) -> TransitionSample

    TransitionSpec::scale

    source
    fn TransitionSpec::scale(from_scale? : Double, to_scale? : Double, duration_ms? : Double, easing? : Easing) -> TransitionSpec

    TransitionSpec::slide

    source
    fn TransitionSpec::slide(from_offset~ : Point, to_offset? : Point, duration_ms? : Double, easing? : Easing) -> TransitionSpec

    TransitionStyle

    source
    pub struct TransitionStyle {
      opacity : Double
      offset : Point
      scale : Point
      foreground : Color?
    } derive(Eq, ToJson, 
    Debug    )

    TransitionStyle::identity

    source

    TransitionStyle::interpolate

    source
    fn TransitionStyle::interpolate(self : TransitionStyle, to : TransitionStyle, progress~ : Double, easing? : Easing, reduced_motion? : Bool) -> TransitionStyle

    TransitionStyle::new

    source
    fn TransitionStyle::new(opacity? : Double, offset? : Point, scale? : Point, foreground? : Color?) -> TransitionStyle

    TransitionStyle::with_foreground

    source
    fn TransitionStyle::with_foreground(self : TransitionStyle, color : Color) -> TransitionStyle

    TransitionStyle::with_offset

    source
    fn TransitionStyle::with_offset(self : TransitionStyle, dx? : Double, dy? : Double) -> TransitionStyle

    TransitionStyle::with_opacity

    source
    fn TransitionStyle::with_opacity(self : TransitionStyle, opacity : Double) -> TransitionStyle

    TransitionStyle::with_scale

    source
    fn TransitionStyle::with_scale(self : TransitionStyle, sx? : Double, sy? : Double) -> TransitionStyle

    TypographyScale

    source
    pub(all) struct TypographyScale {
      display : FontSpec
      headline : FontSpec
      title : FontSpec
      subtitle : FontSpec
      body : FontSpec
      label : FontSpec
      caption : FontSpec
      overline : FontSpec
      control : FontSpec
    } derive(Eq, ToJson, 
    Debug    )

    TypographyScale::default

    source

    View

    source
    pub struct View[Msg] {
      // private fields
    }

    View::accepts_focus

    source
    fn[Msg] View::accepts_focus(self : View[Msg]) -> Bool

    View::accessibility_label

    source
    fn[Msg] View::accessibility_label(self : View[Msg], label : String) -> View[Msg]

    View::align

    source
    fn[Msg] View::align(self : View[Msg], alignment? : Alignment) -> View[Msg]

    View::aspect_ratio

    source
    fn[Msg] View::aspect_ratio(self : View[Msg], ratio : Double) -> View[Msg]

    View::background

    source
    fn[Msg] View::background(self : View[Msg], color : Color) -> View[Msg]

    View::background_brush

    source
    fn[Msg] View::background_brush(self : View[Msg], brush : Brush) -> View[Msg]

    View::border

    source
    fn[Msg] View::border(self : View[Msg], style : BorderStyle) -> View[Msg]

    View::build_child

    source
    fn[Msg] View::build_child(self : View[Msg]) -> (ComponentContext) -> View[Msg]?

    View::caption

    source
    fn[Msg] View::caption(self : View[Msg]) -> View[Msg]

    View::child_constraints

    source
    fn[Msg] View::child_constraints(self : View[Msg], constraints : Constraints) -> Constraints

    View::child_environment

    source
    fn[Msg] View::child_environment(self : View[Msg], environment : Environment) -> Environment

    View::child_style

    source
    fn[Msg] View::child_style(self : View[Msg], style : ViewStyle) -> ViewStyle

    View::children

    source
    fn[Msg] View::children(self : View[Msg]) -> Array[View[Msg]]

    View::clip

    source
    fn[Msg] View::clip(self : View[Msg]) -> View[Msg]

    View::corner_radius

    source
    fn[Msg] View::corner_radius(self : View[Msg], radius : Double) -> View[Msg]

    View::cross_axis_alignment

    source
    fn[Msg] View::cross_axis_alignment(self : View[Msg], alignment : CrossAxisAlignment) -> View[Msg]

    View::disabled

    source
    fn[Msg] View::disabled(self : View[Msg], disabled? : Bool) -> View[Msg]

    View::environment

    source
    fn[Msg] View::environment(self : View[Msg], environment : Environment) -> View[Msg]

    View::event

    source
    fn[Msg] View::event(self : View[Msg], context : ViewEventContext) -> ViewEventResult[Msg]

    View::expanded

    source
    fn[Msg] View::expanded(self : View[Msg], weight? : Double) -> View[Msg]

    View::flex_weight

    source
    fn[Msg] View::flex_weight(self : View[Msg]) -> Double

    View::flexible

    source
    fn[Msg] View::flexible(self : View[Msg], weight? : Double) -> View[Msg]

    View::focus_trap

    source
    fn[Msg] View::focus_trap(self : View[Msg], enabled? : Bool) -> View[Msg]

    View::focusable

    source
    fn[Msg] View::focusable(self : View[Msg], focusable? : Bool) -> View[Msg]

    View::font

    source
    fn[Msg] View::font(self : View[Msg], font : FontSpec) -> View[Msg]

    View::foreground

    source
    fn[Msg] View::foreground(self : View[Msg], color : Color) -> View[Msg]

    View::frame

    source
    fn[Msg] View::frame(self : View[Msg], width? : Double, height? : Double, min_width? : Double, min_height? : Double, max_width? : Double, max_height? : Double) -> View[Msg]

    View::identity

    source
    fn[Msg] View::identity(self : View[Msg]) -> ViewIdentity

    View::intrinsic_height

    source
    fn[Msg] View::intrinsic_height(self : View[Msg]) -> View[Msg]

    View::intrinsic_width

    source
    fn[Msg] View::intrinsic_width(self : View[Msg]) -> View[Msg]

    View::key

    source
    fn[Msg] View::key(self : View[Msg], value : String) -> View[Msg]

    View::keyboard_shortcut

    source
    fn[Msg] View::keyboard_shortcut(self : View[Msg], shortcut : KeyboardShortcut) -> View[Msg]

    View::layout

    source
    fn[Msg] View::layout(self : View[Msg], context : ViewLayoutContext) -> ViewLayoutResult

    View::layout_priority

    source
    fn[Msg] View::layout_priority(self : View[Msg], priority : Double) -> View[Msg]

    View::main_axis_alignment

    source
    fn[Msg] View::main_axis_alignment(self : View[Msg], alignment : MainAxisAlignment) -> View[Msg]

    View::map

    source
    fn[Msg, NextMsg] View::map(self : View[Msg], map : (Msg) -> NextMsg) -> View[NextMsg]

    View::mono

    source
    fn[Msg] View::mono(self : View[Msg]) -> View[Msg]

    View::node

    source
    fn[Msg] View::node(identity~ : () -> ViewIdentity, revision? : () -> String, paint_revision? : () -> String, children? : () -> Array[View[Msg]], build_child? : (ComponentContext) -> View[Msg]?, child_constraints? : (Constraints) -> Constraints, child_environment? : (Environment) -> Environment, child_style? : (ViewStyle) -> ViewStyle, layout~ : (ViewLayoutContext) -> ViewLayoutResult, paint? : (ViewPaintContext) -> ViewPaintPlan, event? : (ViewEventContext) -> ViewEventResult[Msg], text_input_state? : (ViewPaintContext) -> TextInputState?, text_command? : (ViewEventContext, CommandIntent, String?) -> ViewTextCommandResult[Msg], semantics? : () -> ViewSemanticsInfo, focusable? : () -> Bool, flex_weight? : () -> Double) -> View[Msg]

    View::offset

    source
    fn[Msg] View::offset(self : View[Msg], dx? : Double, dy? : Double) -> View[Msg]

    View::on_double_tap

    source
    fn[Msg] View::on_double_tap(self : View[Msg], message : Msg) -> View[Msg]

    View::on_drag

    source
    fn[Msg] View::on_drag(self : View[Msg], handler : (DragGestureEvent) -> Msg) -> View[Msg]

    View::on_drag_with_frame

    source
    fn[Msg] View::on_drag_with_frame(self : View[Msg], handler : (DragGestureEvent, Rect) -> Msg) -> View[Msg]

    View::on_file_drop

    source
    fn[Msg] View::on_file_drop(self : View[Msg], handler : (Array[String], Point) -> Msg) -> View[Msg]

    View::on_long_press

    source
    fn[Msg] View::on_long_press(self : View[Msg], message : Msg) -> View[Msg]

    View::on_tap

    source
    fn[Msg] View::on_tap(self : View[Msg], message : Msg) -> View[Msg]

    View::opacity

    source
    fn[Msg] View::opacity(self : View[Msg], opacity : Double) -> View[Msg]

    View::padding

    source
    fn[Msg] View::padding(self : View[Msg], value : Double) -> View[Msg]

    View::paint

    source
    fn[Msg] View::paint(self : View[Msg], context : ViewPaintContext) -> ViewPaintPlan

    View::paint_revision

    source
    fn[Msg] View::paint_revision(self : View[Msg]) -> String

    View::presence

    source
    fn[Msg] View::presence(self : View[Msg], present~ : Bool, spec? : TransitionSpec, progress? : Double, reduced_motion? : Bool) -> View[Msg]

    View::repaint_boundary

    source
    fn[Msg] View::repaint_boundary(self : View[Msg]) -> View[Msg]

    View::revision

    source
    fn[Msg] View::revision(self : View[Msg]) -> String

    View::scale

    source
    fn[Msg] View::scale(self : View[Msg], sx? : Double, sy? : Double) -> View[Msg]

    View::semantics

    source
    fn[Msg] View::semantics(self : View[Msg]) -> ViewSemanticsInfo

    View::semantics_action

    source
    fn[Msg] View::semantics_action(self : View[Msg], action : SemanticsAction) -> View[Msg]

    View::semantics_checked

    source
    fn[Msg] View::semantics_checked(self : View[Msg], checked? : Bool) -> View[Msg]

    View::semantics_description

    source
    fn[Msg] View::semantics_description(self : View[Msg], description : String) -> View[Msg]

    View::semantics_dismiss_action

    source
    fn[Msg] View::semantics_dismiss_action(self : View[Msg]) -> View[Msg]

    View::semantics_expanded

    source
    fn[Msg] View::semantics_expanded(self : View[Msg], expanded? : Bool) -> View[Msg]

    View::semantics_invalid

    source
    fn[Msg] View::semantics_invalid(self : View[Msg], invalid? : Bool) -> View[Msg]

    View::semantics_level

    source
    fn[Msg] View::semantics_level(self : View[Msg], level : Int) -> View[Msg]

    View::semantics_pressed

    source
    fn[Msg] View::semantics_pressed(self : View[Msg], pressed? : Bool) -> View[Msg]

    View::semantics_required

    source
    fn[Msg] View::semantics_required(self : View[Msg], required? : Bool) -> View[Msg]

    View::semantics_role

    source
    fn[Msg] View::semantics_role(self : View[Msg], role : SemanticsRole) -> View[Msg]

    View::semantics_selected

    source
    fn[Msg] View::semantics_selected(self : View[Msg], selected? : Bool) -> View[Msg]

    View::semantics_url

    source
    fn[Msg] View::semantics_url(self : View[Msg], url : String) -> View[Msg]

    View::shadow

    source
    fn[Msg] View::shadow(self : View[Msg], style : ShadowStyle) -> View[Msg]

    View::spacing

    source
    fn[Msg] View::spacing(self : View[Msg], spacing : Double) -> View[Msg]

    View::text_command

    source
    fn[Msg] View::text_command(self : View[Msg], context : ViewEventContext, intent : CommandIntent, paste_text? : String?) -> TextCommandResult

    View::text_command_result

    source
    fn[Msg] View::text_command_result(self : View[Msg], context : ViewEventContext, intent : CommandIntent, paste_text? : String?) -> ViewTextCommandResult[Msg]

    View::text_input_state

    source
    fn[Msg] View::text_input_state(self : View[Msg], context : ViewPaintContext) -> TextInputState?

    View::theme

    source
    fn[Msg] View::theme(self : View[Msg], theme : Theme) -> View[Msg]

    View::title

    source
    fn[Msg] View::title(self : View[Msg]) -> View[Msg]

    View::transition

    source
    fn[Msg] View::transition(self : View[Msg], spec? : TransitionSpec, progress? : Double, reduced_motion? : Bool) -> View[Msg]

    ViewDirtyHint

    source
    pub(all) enum ViewDirtyHint {
      ViewClean
      ViewPaintDirty
      ViewLayoutDirty
      ViewBuildDirty
    } derive(Eq, 
    Debug    )

    ViewEnvironment

    source
    type ViewEnvironment

    ViewEnvironment::environment

    source
    fn ViewEnvironment::environment(self : ViewEnvironment) -> Environment

    ViewEnvironment::new

    source
    fn ViewEnvironment::new(viewport_size~ : Size, environment~ : Environment) -> ViewEnvironment

    ViewEnvironment::viewport_size

    source
    fn ViewEnvironment::viewport_size(self : ViewEnvironment) -> Size

    ViewEventContext

    source
    pub(all) struct ViewEventContext {
      frame : Rect
      child_frames : Array[Rect]
      event : AppEvent
      focused : Bool
      state : ViewStateContext
      text_control : TextControlStateContext
      text_system : TextSystem
      environment : Environment
      style : ViewStyle
      now_ms : Double
    }

    ViewEventResult

    source
    pub(all) struct ViewEventResult[Msg] {
      changed : Bool
      activated : Bool
      focused : Bool
      captured : Bool
      state : ViewStateContext?
      text_control : TextControlStateContext?
      dirty : ViewDirtyHint
      messages : Array[Msg]
    } derive(Eq, 
    Debug    )

    ViewEventResult::ignored

    source
    fn[Msg] ViewEventResult::ignored() -> ViewEventResult[Msg]

    ViewEventResult::message

    source
    fn[Msg] ViewEventResult::message(message : Msg) -> ViewEventResult[Msg]

    ViewIdentity

    source
    pub(all) struct ViewIdentity {
      kind : String
      key : Key?
    } derive(Eq)

    ViewIdentity::new

    source
    fn ViewIdentity::new(kind~ : String, key? : String?) -> ViewIdentity

    ViewLayoutContext

    source
    pub(all) struct ViewLayoutContext {
      constraints : Constraints
      child_sizes : Array[Size]
      child_flex_weights : Array[Double]
      text_system : TextSystem
      environment : Environment
      style : ViewStyle
    }

    ViewLayoutResult

    source
    pub(all) struct ViewLayoutResult {
      size : Size
      child_frames : Array[Rect]
    } derive(Eq, 
    Debug    )

    ViewLayoutResult::new

    source
    fn ViewLayoutResult::new(size~ : Size, child_frames? : Array[Rect]) -> ViewLayoutResult

    ViewPaintContext

    source
    pub(all) struct ViewPaintContext {
      frame : Rect
      child_frames : Array[Rect]
      focused : Bool
      state : ViewStateContext
      text_control : TextControlStateContext
      environment : Environment
      style : ViewStyle
      text_system : TextSystem
      now_ms : Double
    }

    ViewPaintLayer

    source
    pub(all) struct ViewPaintLayer {
      frame : Rect
      cache_key : String
      content_revision : Int
      commands : Array[DrawCommand]
      overlay_commands : Array[DrawCommand]
      platform_views : Array[PlatformViewPlacement]
    } derive(Eq, 
    Debug    )

    ViewPaintLayer::new

    source
    fn ViewPaintLayer::new(frame~ : Rect, cache_key~ : String, content_revision~ : Int, commands? : Array[DrawCommand], overlay_commands? : Array[DrawCommand], platform_views? : Array[PlatformViewPlacement]) -> ViewPaintLayer

    ViewPaintPlan

    source
    pub(all) struct ViewPaintPlan {
      commands : Array[DrawCommand]
      child_layers : Array[ViewPaintLayer]
      post_commands : Array[DrawCommand]
      overlay_commands : Array[DrawCommand]
      platform_views : Array[PlatformViewPlacement]
      repaint_boundary : Bool
      animating : Bool
    } derive(Eq, 
    Debug    )

    ViewPaintPlan::animating_commands

    source
    fn ViewPaintPlan::animating_commands(commands : Array[DrawCommand]) -> ViewPaintPlan

    Like ViewPaintPlan::commands but flags the paint as a mid-animation sample. The runtime keeps requesting redraws while any painted plan in the tree reports animating=true. Controls set this when their transition progress < 1.0 (and reduced_motion is not in effect).

    ViewPaintPlan::commands

    source
    fn ViewPaintPlan::commands(commands : Array[DrawCommand]) -> ViewPaintPlan

    ViewPaintPlan::empty

    source

    ViewSemanticsInfo

    source
    pub(all) struct ViewSemanticsInfo {
      role : SemanticsRole
      level : Int?
      url : String
      label : String
      value : String
      description : String
      actions : Array[SemanticsAction]
      disabled : Bool?
      selected : Bool?
      pressed : Bool?
      checked : Bool?
      expanded : Bool?
      invalid : Bool?
      required : Bool?
    } derive(Eq, 
    Debug    )

    ViewSemanticsInfo::new

    source
    fn ViewSemanticsInfo::new(role? : SemanticsRole, level? : Int, url? : String, label? : String, value? : String, description? : String, actions? : Array[SemanticsAction], disabled? : Bool, selected? : Bool, pressed? : Bool, checked? : Bool, expanded? : Bool, invalid? : Bool, required? : Bool) -> ViewSemanticsInfo

    ViewStateContext

    source
    pub(all) struct ViewStateContext {
      focused : Bool
      hovered : Bool
      pressed : Bool
      selected : Bool
      checked : Bool
      expanded : Bool
      disabled : Bool
      scratch : String
    } derive(Eq, 
    Debug    )

    ViewStyle

    source
    pub(all) struct ViewStyle {
      font : FontSpec?
      foreground : Color?
      background : Brush?
      corner_radius : Double?
    } derive(Eq, ToJson, 
    Debug    )

    ViewStyle::empty

    source
    fn ViewStyle::empty() -> ViewStyle

    ViewStyle::from_theme

    source
    fn ViewStyle::from_theme(theme : Theme) -> ViewStyle

    ViewStyle::merge

    source
    fn ViewStyle::merge(self : ViewStyle, next : ViewStyle) -> ViewStyle

    ViewTextCommandResult

    source
    pub(all) struct ViewTextCommandResult[Msg] {
      result : TextCommandResult
      text_control : TextControlStateContext?
      messages : Array[Msg]
    } derive(Eq, 
    Debug    )

    ViewTextCommandResult::ignored

    source
    fn[Msg] ViewTextCommandResult::ignored() -> ViewTextCommandResult[Msg]

    ViewTextCommandResult::new

    source
    fn[Msg] ViewTextCommandResult::new(result~ : TextCommandResult, text_control? : TextControlStateContext?, messages? : Array[Msg]) -> ViewTextCommandResult[Msg]

    VisualStyle

    source
    pub(all) struct VisualStyle {
      background : Brush?
      foreground : Color?
      border : BorderStyle?
      shadow : ShadowStyle?
      radius : Double?
      opacity : Double?
    } derive(Eq, ToJson, 
    Debug    )

    VisualStyle::empty

    source
    fn VisualStyle::empty() -> VisualStyle

    active_text_selection

    source
    fn active_text_selection(selection : TextRange?) -> TextRange?

    animated_color

    source
    fn animated_color(from~ : Color, to~ : Color, progress~ : Double, easing? : Easing, reduced_motion? : Bool) -> Color

    animated_point

    source
    fn animated_point(from~ : Point, to~ : Point, progress~ : Double, easing? : Easing, reduced_motion? : Bool) -> Point

    animated_value

    source
    fn animated_value(from~ : Double, to~ : Double, progress~ : Double, easing? : Easing, reduced_motion? : Bool) -> Double

    cancel_component_effects

    source
    fn cancel_component_effects(effects : Array[ComponentEffect], reason? : ComponentEffectCancelReason) -> Unit

    clamp_int

    source
    fn clamp_int(value : Int, min : Int, max : Int) -> Int

    composition_cursor_offset

    source
    fn composition_cursor_offset(control : TextControlStateContext, composition : String) -> Int

    composition_start_index

    source
    fn composition_start_index(text : String, caret : Int, selection : TextRange?) -> Int

    default_text_commands

    source
    fn default_text_commands() -> Array[ActionCommand]

    delete_grapheme_range

    source
    fn delete_grapheme_range(boundaries : 
    TextGraphemeBoundaries    , caret : Int, before : Int, after : Int) -> TextRange

    bridges the core TextRange contract to the unicode package's API.

    fallback_stabilize_grapheme_cluster_carets

    source
    fn fallback_stabilize_grapheme_cluster_carets(text : String, carets : Array[Double]) -> Array[Double]

    the cluster's leading caret coordinate.

    focus_scope_command_intent

    source
    fn focus_scope_command_intent(event : KeyboardEvent) -> CommandIntent?

    hit_test

    source
    fn hit_test(layout : LayoutResult, point : Point) -> Bool

    is_redo_shortcut

    source
    fn is_redo_shortcut(event : KeyboardEvent) -> Bool

    is_select_all_shortcut

    source
    fn is_select_all_shortcut(event : KeyboardEvent) -> Bool

    is_undo_shortcut

    source
    fn is_undo_shortcut(event : KeyboardEvent) -> Bool

    max_int

    source
    fn max_int(a : Int, b : Int) -> Int

    min_int

    source
    fn min_int(a : Int, b : Int) -> Int

    move_text_caret

    source
    fn move_text_caret(text : String, caret : Int, selection : TextRange?, direction : TextCaretDirection, extend_selection~ : Bool) -> TextCaretMoveResult

    normalize_grapheme_range

    source

    TextRange contract to the unicode package's GraphemeRange API.

    optional_rect_union

    source
    fn optional_rect_union(left : Rect?, right : Rect?) -> Rect?

    replace_text_range

    source
    fn replace_text_range(text : String, range : TextRange, replacement : String) -> String

    resolve_minimal_theme

    source
    fn resolve_minimal_theme(spec : ThemeSpec, system_scheme : ColorScheme) -> Theme

    Resolve the Minimal preset. This is the canonical resolver: it picks the palette by scheme, applies density to spacing, applies contrast adjustment, zeroes motion when reduced motion is requested, and derives default ComponentThemes from the resolved palette.

    resolve_theme

    source
    fn resolve_theme(spec : ThemeSpec, system_scheme : ColorScheme) -> Theme

    Resolve a ThemeSpec against a system color scheme. For branded presets this resolves the Minimal base; branded addons must call resolve_minimal_theme and then replace the palette/components themselves.

    selected_text

    source
    fn selected_text(text : String, selection : TextRange?) -> String

    surrounding_delete_range

    source
    fn surrounding_delete_range(text : String, caret : Int, before : Int, after : Int) -> TextRange

    text_input_grapheme_selection

    source
    fn text_input_grapheme_selection(boundaries : 
    TextGraphemeBoundaries    , selection : TextRange?) -> TextRange?

    text_next_grapheme_caret_boundary

    source
    fn text_next_grapheme_caret_boundary(text : String, caret : Int) -> Int

    Returns the next grapheme boundary after caret.

    text_previous_grapheme_caret_boundary

    source
    fn text_previous_grapheme_caret_boundary(text : String, caret : Int) -> Int

    Returns the previous grapheme boundary before caret.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io