TileSchemaBuilderScope

Conditionally renders tiles based on the current window size class. Children are composed only when both widthVisibility and heightVisibility are satisfied — otherwise nothing is emitted (the children are not composed, not merely hidden). VisibleFrom(breakpoint) shows from the rank above the given breakpoint upwards (exclusive); VisibleUntil(breakpoint) shows at or below it (inclusive). Width and height are evaluated independently, so one may be satisfied while the other is not — in that case the children still stay hidden. When both conditions hold, the children are hosted in a Box carrying style and visibility. Dispatches onDisplay once when composed regardless of the breakpoints, and dispatches the width/height satisfied/not-satisfied triggers on first composition and on every condition change.

Registers builder as a child of this scope, snapshotting the CompositionLocal values currently active (via BuildContext.get) into GenericBuilder.compositionLocals — captured now, at DSL-call time, not later when build actually invokes it. Called once per nested DSL call (SimpleText(...), SendNetworkRequest(...), etc.) by each such call's own top-level builder function.

Renders a Material 3 assist chip displaying text as its label, with optional leadingIcon and trailingIcon. variant picks the visual style — default (outlined) or elevated. The chip is stateless (no selected state) and both icons are purely decorative — tapping either fires the same chip-level onClick. Dispatches onClick when tapped.

Renders a Coil AsyncImage that loads its content from model — a remote URL (urlImageModel), raw bytes (arrayOfBytesImageModel) or a base64 string (base64ImageModel, decoded on the client before being handed to Coil). Dispatches onAsyncImageLoadStart / onAsyncImageLoadSuccess / onAsyncImageLoadFailure on every load state change, including reloads triggered by a model change, so they may fire more than once over the tile's lifetime. The tile is not clickable and fires no display trigger — wrap it in a Box or Card for tap handling. There is no built-in placeholder or error image: render one yourself by reacting to the load triggers.

Renders a Material 3 badge. When content is non-null it is shown as the badge's text label and the badge takes its larger, pill-shaped form; when null the badge is the small empty dot. This is a standalone badge, not attached to a sibling tile — position it yourself, e.g. inside a Box aligned over the tile it decorates. Dispatches no triggers and is not clickable.

Renders a Material 3 bottom app bar with actions laid out on the leading side and an optional floatingActionButton docked at the trailing edge. The bar itself dispatches no triggers and is not clickable — wire events on the action tiles instead.

Renders a Compose Box that stacks tiles on top of each other in declaration order (later children paint above earlier ones), all positioned by alignment. Never scrollable, and publishes no scope CompositionLocal, so children cannot use column/row scope modifiers such as weight. Dispatches onDisplay once when composed; onClick/onLongPress are wired only when the matching event is declared on this tile — with neither declared, the box is not made interactive.

Builds every registered Builder in registration order, restoring each one's own GenericBuilder.compositionLocals snapshot (via BuildContext.with) for the duration of its own GenericBuilder.build call.

Renders a Material 3 button. The visual variant is picked by buttonType (filled, elevated, filled tonal, outlined or text) and its corner style by shape (square or rounded). Shows text together with an optional icon positioned by iconPosition. When loading is true the button shows a spinner instead of its content, and is disabled for real regardless of enabled so a slow action cannot be submitted twice. Dispatches onClick when tapped while interactive.

Renders a Material 3 card hosting tiles stacked vertically in a column scope. kind picks the visual style — default, elevated or outlined. Children can use column scope modifiers such as weight. Dispatches onDisplay once when composed and onClick when the card is tapped.

Renders a Material 3 horizontal carousel over tiles, one child per item. type picks the layout — multiBrowse sizes items around a preferred width with shrunken edge items, or uncontained uses a fixed item width. itemSpacing and contentPadding (applied horizontally only) are in dp, and userScrollEnabled toggles manual swiping. Listens for scroll-to-begin/end and next/previous-item broadcasts addressed to its id — it shares the pager's broadcast, so the same commands work on both tile types. Requesting the next item past the last one (or the previous one before the first) is a no-op. Children are rendered by index with no scope CompositionLocal. Dispatches onDisplay once when composed, and onPageChanged whenever the current item changes (skipping the initial item) — once per matching direction (any / start / end / that exact index).

Renders a bare Material 3 checkbox reflecting checked. Draws only the box — no label — so pair it with a SimpleText inside a Row when a caption is needed. Toggling flips checked locally on the client (no round trip needed for the new value to take effect), then dispatches onCheck (when it becomes checked) or onUncheck (when it becomes unchecked), always followed by onCheckChanged. The current checked value can be read from this tile by its id via GetData.

Renders a Material 3 circular progress indicator. When progress is null the indicator is indeterminate (endless spinner); when set, it is determinate and shows that fraction, where 0f is empty and 1f is complete. Colors and stroke are Material defaults — only style is applied. Dispatches no triggers and is not clickable. Drive a determinate indicator by pushing new progress values with UpdateTiles.

Renders a Compose Column stacking tiles vertically, spaced by arrangement and aligned horizontally by alignment. When scrollable is true the column becomes vertically scrollable — every child is composed eagerly, so prefer LazyColumn for long lists. Publishes its column scope to children so they can use scope modifiers such as weight. When filterChildrenByTerm is set, only children whose searchableTerms contain that term (case-insensitive substring match) are rendered — children without searchableTerms are filtered out. Listens for scroll-to-top/bottom/offset broadcasts addressed to its id. Dispatches onDisplay once when composed, onClick/onLongPress only when declared, and onScrolled on scroll direction changes while scrollable is true.

Renders a read-only text field that opens a Material 3 date picker dialog when tapped. kind picks the field style — filled or outlined. Always shows a calendar leading icon, displays selectedDate (empty when null, as an ISO yyyy-MM-dd string), forwards enabled and supportingText, and switches to Material's error styling when state is error. Typing is impossible — the field is read-only. Opening, closing and date selection are handled entirely on the client: pressing the field opens the dialog, confirming stores the picked date and closes it, cancelling or dismissing just closes it — none of this needs a round trip to the server. The dialog's buttons are labelled with confirmLabel and cancelLabel, and the confirm button stays disabled until a date is picked, so confirming always yields a date. Dispatches onDatePickerOpen when pressed while closed, onDateSelected (carrying the ISO date string) when confirmed, and onDatePickerClose when pressed while open, dismissed, cancelled, or right after a confirm. The current selectedDate can be read from this tile by its id via GetData — it produces no entry at all when no date is selected.

Renders a Material 3 exposed dropdown menu: a read-only anchor field showing the label of the currently selected option, plus a dropdown listing every entry in options. kind picks the anchor style — filled or outlined. enabled and supportingText are forwarded, and state set to error switches the field into Material's error styling. The anchor displays the label of the option whose id equals selectedOptionId — selectedOptionId must match one of options' ids, or building this tile throws. Opening, closing and item selection are handled entirely on the client: tapping the anchor toggles the menu, tapping an item stores the new selection and closes the menu, dismissing (tapping outside) just closes it — none of this needs a round trip to the server. Dispatches onDropdownListOpen when the anchor is tapped while closed; onDropdownListItemSelected (carrying the picked option's id) when an item is picked; and onDropdownListClose whenever the menu closes — anchor tapped while open, dismissed by tapping outside, or right after an item is picked. The current selectedOptionId can be read from this tile by its id via GetData.

Renders a Material 3 filter chip with a toggleable selected state, text as its label and optional leadingIcon / trailingIcon. variant picks the visual style — default (outlined) or elevated. Tapping the chip flips selected locally on the client (no round trip needed for the new value to take effect), then dispatches onCheck (when it becomes selected) or onUncheck (when it becomes unselected), always followed by onCheckChanged. The current selected value can be read from this tile by its id via GetData.

Renders a Compose CSS-flexbox layout hosting tiles. direction sets the main axis (and its reversal), justifyContent distributes children along the main axis, alignItems aligns children on the cross axis of a single line, alignContent distributes the lines themselves (only takes effect when wrap allows multiple lines), and wrap controls whether items wrap. columnGap / rowGap are in dp. Publishes its flex scope to children so they can use flex modifiers (grow, shrink, basis, align-self). When filterChildrenByTerm is set, only children whose searchableTerms contain that term (case-insensitive substring match) are rendered — children without searchableTerms are filtered out. Never scrollable — every child is composed eagerly. Dispatches onDisplay once when composed, onClick only when declared.

Renders a Material 3 floating action button. Its size is picked by size (default/small, medium or large), which also scales icon accordingly (24dp, 28dp or 36dp). Dispatches onClick when tapped.

Renders a Compose FlowRow laying tiles out horizontally and wrapping onto new lines when they no longer fit. horizontalArrangement spaces items within a line, verticalArrangement spaces the lines themselves, and maxItemsInEachRow caps how many children a single line may hold (unlimited by default). Publishes its flow-row scope to children so they can use modifiers such as weight and fillMaxRowHeight. When filterChildrenByTerm is set, only children whose searchableTerms contain that term (case-insensitive substring match) are rendered — children without searchableTerms are filtered out. Never scrollable — every child is composed eagerly. Dispatches onDisplay once when composed, onClick only when declared.

Renders a Compose CSS-grid-like layout hosting tiles. columns and rows declare the track template (each track fixed in dp, a fraction of available space, an fr-flexible unit, auto, max-content or min-content); when rows is left empty, row tracks are derived implicitly. flow decides whether children are placed row-first or column-first, and columnGap / rowGap (in dp) set the spacing between tracks. Publishes its grid scope to children so they can use grid modifiers (row/column span and placement). When filterChildrenByTerm is set, only children whose searchableTerms contain that term (case-insensitive substring match) are rendered — children without searchableTerms are filtered out. Never scrollable — every child is composed eagerly. Dispatches onDisplay once when composed, onClick/onLongPress only when declared on this tile.

Renders a single Material Symbol described by icon, honouring its name, color, size and style. This is the standalone icon tile — its style is applied to the icon's own layout node. Dispatches no triggers at all — not even onDisplay — and is not clickable, so any events declared on it are never fired. Use IconButton for a tappable icon, or wrap this tile in a clickable container.

Renders a Material 3 icon button. The visual variant is picked by buttonType (default, filled, filled tonal or outlined). Shows icon with its color, size and style applied. When loading is true the button shows a spinner instead of the icon, and is disabled for real regardless of enabled so a slow action cannot be submitted twice. Dispatches onClick when tapped while interactive.

Renders a Compose Image from a drawable bundled with the client application. resourceName is looked up in the app's DrawableResourcesHolder; when no resource is registered under that name nothing is rendered at all — there is no fallback and no error trigger. Dispatches no triggers and is not clickable. Use AsyncImage for images that come from the network or from raw bytes — this tile can only show assets that ship with the client.

Renders a Material 3 input chip with a toggleable selected state, text as its label and optional leadingIcon / trailingIcon. Tapping the chip flips selected locally on the client (no round trip needed for the new value to take effect), then dispatches onCheck (when it becomes selected) or onUncheck (when it becomes unselected), always followed by onCheckChanged. The trailing icon is decorative — tapping anywhere on the chip toggles it. The current selected value can be read from this tile by its id via GetData.

Renders a Compose LazyColumn over tiles — one lazy item per child, keyed by the child's id — spaced by arrangement and aligned horizontally by alignment. Only visible children are composed, so prefer this over Column for long or paginated lists. Publishes each item's lazy scope to its child, so children can use modifiers such as animateItem (but not ColumnScope.weight). When filterChildrenByTerm is set, only children whose searchableTerms contain that term (case-insensitive substring match) are rendered — children without searchableTerms are filtered out. When scrollThreshold is set, the list fires its threshold trigger once fewer than or exactly that many items remain past the last visible one; it does not fire again until the list grows, and considerLoadingItemAtEndOnThresholdReached additionally requires it to grow by more than one item (accounting for a trailing loading placeholder). Listens for scroll-to-top/bottom/item broadcasts addressed to its id. When displayScrollbar is true, draws a vertical scrollbar on the trailing edge (useful on desktop/web). Dispatches onDisplay once when composed, onClick only when declared, onScrolled on scroll direction changes, and the scroll-threshold trigger as described above.

Renders a Compose LazyRow over tiles — one lazy item per child, keyed by the child's id — spaced by arrangement and aligned vertically by alignment. Only visible children are composed, so prefer this over Row for long or paginated horizontal lists. Publishes each item's lazy scope to its child, so children can use modifiers such as animateItem (but not RowScope.weight). When filterChildrenByTerm is set, only children whose searchableTerms contain that term (case-insensitive substring match) are rendered — children without searchableTerms are filtered out. When scrollThreshold is set, the list fires its threshold trigger once fewer than or exactly that many items remain past the last visible one; it does not fire again until the list grows, and considerLoadingItemAtEndOnThresholdReached additionally requires it to grow by more than one item (accounting for a trailing loading placeholder). Listens for scroll-to-start/end/item broadcasts addressed to its id. When displayScrollbar is true, draws a horizontal scrollbar along the bottom edge (useful on desktop/web). Dispatches onDisplay once when composed, onClick only when declared, onScrolled on scroll direction changes, and the scroll-threshold trigger as described above.

Renders a plain Column whose content is fetched from the network at display time: the tile calls url with method, body and headers, expects a JSON array of tile schemas back, and renders them in place of placeholderTiles. placeholderTiles are shown while the request is in flight (fired once, on the IO dispatcher), and failureTiles replace them if the request or the response decoding fails. A local reload event clears the loaded state and retries. The request is issued directly by the renderer, not through the event pipeline, so it is not affected by event chaining. Children are laid out with no scope CompositionLocal and no scrolling.

Renders a Material 3 linear progress indicator. When progress is null the indicator is indeterminate (endless sweep); when set, it is determinate and shows that fraction, where 0f is empty and 1f is complete. Colors, track and stroke cap are Material defaults — only style is applied. Dispatches no triggers and is not clickable. Drive a determinate indicator by pushing new progress values with UpdateTiles.

Renders an anchor — tiles, laid out with Box semantics and carrying style and visibility — with a Material 3 dropdown menu attached to it. The menu lists one entry per item declared via items (built with addMenuItem), each showing its label plus an optional leading/trailing icon. The menu uses the large theme shape, respects the system bars and is capped at 400dp tall (scrolling beyond that). expanded drives the menu; dismissing it (tapping outside or pressing back) flips expanded locally on the client, with no server round trip needed. Opening and closing from the server side is done with a ToggleMenu event pointing at this tile's id — typically wired to the anchor's click to open, and to an item's click chain to close after acting on the selection. style and visibility apply to the anchor only — the dropdown itself is positioned by Material and unaffected by them. Dispatches onMenuItemClick(itemId) when an item is tapped, so events can be wired per item.

Renders a Material 3 navigation bar with one entry per item declared via items (built with item). An item is selected when its id equals selectedItemId; the selected item's icon is drawn in its filled variant, the others outlined, and its label is centered under the icon (or omitted when not given). Tapping an item flips selectedItemId locally on the client (no server round trip needed for the highlight to move) — tapping the already-selected item still fires everything again. The bar itself is not clickable and fires no display trigger; it only tracks the selected item, so performing the actual navigation is up to the events wired to the item clicks. Dispatches onNavigationBarItemClick(itemId) when an item is tapped, so events can be wired per item.

Renders a Material 3 navigation rail — the side-rail counterpart of NavigationBar — with one entry per item declared via items (built with addItem). An item is selected when its id equals selectedItemId; the selected item's icon is drawn in its filled variant, the others outlined, and its label is centered under the icon (or omitted when not given). header is rendered above the items and footer at the very bottom (pushed down by a weighted spacer so it hugs the bottom edge); both are optional, arbitrary tiles. Tapping an item flips selectedItemId locally on the client (no server round trip needed for the highlight to move) — tapping the already-selected item still fires everything again. The rail itself is not clickable and fires no display trigger; it only tracks the selected item, so performing the actual navigation is up to the events wired to the item clicks. Dispatches onNavigationRailItemClick(itemId) when an item is tapped, so events can be wired per item.

Hosts a self-contained navigation back stack inside a tile, so a region of a screen can navigate independently of the rest. The stack starts at startEntryId and every screen it can show is declared via entries (built with entry). On first composition the tile registers itself under navigatorId — that id is how Navigate events address this graph — and that registration (along with each entry) is torn down when the tile leaves composition, so the graph and its entries only exist while the tile is on screen; each entry gets its own state holder, so screen state survives navigating back and forth within the graph. The system back gesture pops this graph's own stack, not the outer one. For each navigation, the entry's own Entry transitions win; when an entry does not define one, defaultTransition / defaultPopTransition / defaultPredictivePopTransition apply; when neither is set the navigation is instantaneous. Dispatches onNavigationEntrySet(screenId) whenever an entry is displayed — including the start destination and every time navigation returns to an entry — so events can be wired per destination.

Renders a horizontal-only Compose HorizontalPager over tiles, one page per child. pageSize chooses between full-width pages (pageFill) and fixed-width pages (pageFixed, in dp); pageSpacing and contentPadding (horizontal only) are dp values, and beyondViewportPageCount controls how many off-screen pages stay composed. Listens for scroll-to-begin/end and next/previous-page broadcasts addressed to its id — requesting the next page past the last one (or the previous one before the first) is a no-op. Children are rendered by index with no scope CompositionLocal. Dispatches onDisplay once when composed, and onPageChanged whenever the settled current page changes (skipping the initial page) — once per matching direction (any / start / end / that exact index); wiring several directions runs several chains for the same page change.

Renders an anchor — tiles, laid out with Box semantics and carrying style and visibility — with a floating popup containing popupTiles over it. The popup is only composed while expanded is true. alignment places the popup relative to the anchor's bounds, and offsetX / offsetY (in dp) are applied on top of that: top/bottom alignments put the popup fully above/below the anchor with offsetY as the gap, start/end-center alignments put it fully to the side with offsetX as the gap (mirrored under RTL), and corner alignments flush-align the popup's matching edge with the anchor's, with offsetX as a plain translation. The final position is clamped to the window, so the popup can never be pushed off screen. focusable, dismissOnBackPress and dismissOnClickOutside control how it can be dismissed. A dismissal (back press, tap outside) flips expanded locally on the client, with no server round trip needed; opening and closing from the server side is done with a TogglePopup event pointing at this tile's id — typically wired to the anchor's click. style and visibility apply to the anchor only — the popup renders in its own window, unaffected by them, and its content is unstyled and undecorated, so wrap popupTiles in a Card or a styled Box for a surface behind it. Dispatches no triggers at all — wire events on the anchor and popup tiles instead.

Renders a Material 3 pull-to-refresh container wrapping tiles, showing the refresh indicator while isRefreshing is true. Pulling flips isRefreshing to true locally on the client (no round trip needed for the spinner to appear) and dispatches onPull — hook the refresh work to that trigger. Stopping the indicator is the server's job: chain a StopRefreshingEventSchema pointing at this tile's id onto the end of the refresh flow, on both the success and failure branch, otherwise it keeps spinning. Children are laid out with Box semantics and no scope CompositionLocal; put a scrollable tile inside for the gesture to feel natural. Dispatches onDisplay once when composed.

Renders a bare Material 3 radio button reflecting selected. Draws only the radio circle — no label — so pair it with a SimpleText inside a Row when a caption is needed. Tapping the button applies mutual exclusion entirely on the client: every radio tile sharing the same groupId sets its own selected state to whether its id matches the tapped tile's id, with no server round trip and no UpdateTiles needed to clear the previously selected button; radios with a different groupId are unaffected. Dispatches onSelect only on the radio button that becomes selected — tapping an already-selected radio fires nothing, and radios that become deselected fire nothing either. The current selected value can be read from this tile by its id via GetData.

Renders a Compose Row laying tiles out horizontally, spaced by arrangement and aligned vertically by alignment. When scrollable is true the row becomes horizontally scrollable — every child is composed eagerly, so prefer LazyRow for long lists. Publishes its row scope to children so they can use scope modifiers such as weight. When filterChildrenByTerm is set, only children whose searchableTerms contain that term (case-insensitive substring match) are rendered — children without searchableTerms are filtered out. Listens for scroll-to-start/end/offset broadcasts addressed to its id. Dispatches onDisplay once when composed, onClick/onLongPress only when declared, and onScrolled on scroll direction changes while scrollable is true.

Renders a Material search field showing query, with placeholder shown when empty. The keyboard's IME action is always "Search". leadingIcon is an arbitrary tile rendered in the leading slot. The trailing slot is shared: while query is empty it shows trailingIcon (if any); as soon as query has text it cross-fades to a built-in clear icon button, so a custom trailing icon is never visible at the same time as the clear button. Typing and pressing clear update the query locally on the client (no server round trip needed for the text to change). This is only the input field — it has no expanded state and shows no suggestion list; pair it with e.g. a LazyColumn whose filterChildrenByTerm is driven by the query to render results. Dispatches onQueryChanged (carrying the new text) on every keystroke and also when clear is pressed (with an empty string); onQueryCleared when the clear button is pressed, right before the query-changed trigger; and onSearch (carrying the current query) when the IME "Search" action is pressed.

Wraps tiles in a Compose SelectionContainer, making the text rendered by its descendants selectable and copyable with the platform's selection handles and context menu. Dispatches no triggers at all — not even onDisplay — so any events declared on this tile are never fired; wire events on the children instead. Children are rendered without a scope CompositionLocal (behaves like a Box for layout) — put a Column or Row inside when a specific arrangement is needed.

Renders a Box hosting tiles with a continuously animated shimmer applied over the whole subtree — the usual way to build a skeleton/loading placeholder out of plain tiles. The shimmer is purely visual: children stay interactive, so build the placeholder out of non-clickable tiles. The tile itself is never clickable, and children are laid out with Box semantics (stacked, no scope CompositionLocal). Dispatches onDisplay once when composed.

Renders plain text showing text. typography provides the base text style, falling back to the ambient default when null; every other styling field overrides one property on top of that base and is ignored when null: color, autoSize, fontSize (sp), fontStyle, fontWeight, fontFamily, letterSpacing (sp), textDecoration, textAlign and lineHeight (sp). overflow defaults to clipping, softWrap to true, maxLines to unbounded and minLines to 1. Dispatches no triggers and is not clickable — wrap it in a Box or Card for tap handling. Renders plain text only — no inline annotations, links or markdown; wrap it in a SelectionContainer to make the text selectable.

Renders a Material 3 suggestion chip displaying text as its label, with an optional leading icon. variant picks the visual style — default (outlined) or elevated. The chip is stateless (no selected state) and icon is decorative only. Dispatches onClick when tapped.

Renders a bare Material 3 switch reflecting checked. Draws only the switch — no label or thumb icon — so pair it with a SimpleText inside a Row when a caption is needed. Toggling flips checked locally on the client (no round trip needed for the new value to take effect), then dispatches onCheck (when it turns on) or onUncheck (when it turns off), always followed by onCheckChanged. The current checked value can be read from this tile by its id via GetData.

Renders tiles and, while they are on screen, subscribes to the app-wide system broadcast channel — the tile that lets host-app signals (push notifications, connectivity changes, anything the client publishes on that channel) drive server-declared event flows. The subscription lives only as long as the tile is composed; while it is off screen, broadcasts are not observed. Children are hosted in a Box carrying style and visibility, so they are stacked rather than emitted into the parent's scope. Dispatches onSystemBroadcast(broadcastId) for each broadcast received, carrying the broadcast payload as the event's incoming data, so events can be wired per broadcast.

Renders a Material 3 tab row with one tab per entry declared via tabItems (built with addTab). tabType picks the emphasis — primary or secondary — and scrollable chooses between a fixed row and a scrollable one. Each tab shows its label and icon, both optional; the selected tab is the one whose id equals selectedTabId — when it matches none of tabItems the first tab is highlighted as a fallback, and an empty tabItems renders nothing at all. When a tab's badge text is set (via addTab), it gets a badge attached to its icon (or its label when it has none) — an empty string renders a small dot badge, any other value renders as the badge's text. Tapping a tab flips selectedTabId locally on the client (no server round trip needed for the indicator to move); the tile only tracks the selection, so swapping the content shown below the tabs is up to the events wired to the tab clicks. Dispatches onTabItemClick(tabId) when a tab is tapped, so events can be wired per tab.

Renders a Material 3 text input field. kind picks the visual style — filled or outlined. label, prefixText, suffixText, supportingText and placeholder are shown only when non-null; enabled, minLines and maxLines are forwarded; state set to error switches the field into Material's error styling. The client keeps its own local text state seeded from value, re-syncing (and moving the caret to the end) whenever the server pushes a new value (e.g. via UpdateTiles); each keystroke updates that local state without a round trip to the server. leadingIcon / trailingIcon render as plain icons by default; setting clickableLeadingIcon / clickableTrailingIcon wraps them in a tappable IconButton that fires its own trigger. keyboardOptions configures capitalization, keyboard type, IME action, autocorrect and show-on-focus; visualTransformation masks the displayed text (e.g. for passwords). Dispatches onTextChanged (carrying the new text) on every keystroke where the text actually differs from value; the matching keyboard trigger (onKeyboardDone/onKeyboardGo/onKeyboardNext/onKeyboardPrevious/onKeyboardSearch/onKeyboardSend) when the IME action set by keyboardOptions is pressed; onLeadingIconClick only when clickableLeadingIcon is true; and onTrailingIconClick only when clickableTrailingIcon is true. The current value can be read from this tile by its id via GetData — an empty value produces no entry at all rather than an empty string.

Renders a read-only text field that opens a Material 3 time picker dialog when tapped. kind picks the field style — filled or outlined. Always shows an alarm leading icon, displays selectedTime (empty when null, as an ISO HH:mm string), forwards enabled and supportingText, and switches to Material's error styling when state is error. Typing is impossible — the field is read-only. The dialog is always 24-hour, uses the vertical layout, and opens at 00:00 when selectedTime is null. Opening, closing and time selection are handled entirely on the client: pressing the field opens the dialog, confirming stores the picked time and closes it, cancelling or dismissing just closes it — none of this needs a round trip to the server. The dialog's buttons are labelled with confirmLabel and cancelLabel. Dispatches onTimePickerOpen when pressed while closed, onTimeSelected (carrying the ISO time string) when confirmed, and onTimePickerClose when pressed while open, dismissed, cancelled, or right after a confirm. The current selectedTime can be read from this tile by its id via GetData — it produces no entry at all when no time is selected.

Wraps tiles in a Material 3 plain tooltip showing text. The tooltip is driven entirely by the platform's own gestures (long press on touch, hover on pointer devices) — the server neither opens nor observes it. position places the tooltip relative to the anchor and spacing (dp) sets the gap from it, defaulting to Material's own spacing when null. showCaret toggles the little pointer arrow, and maxWidth, shape, contentColor and containerColor each override the corresponding Material default when non-null. style and visibility apply to the anchor, not to the tooltip surface, whose look is controlled by the fields above. Only plain tooltips are supported — there is no rich variant with a title and actions. Dispatches no triggers at all — wire events on the wrapped tiles instead.

Renders a Material 3 top app bar. barStyle picks the visual variant — default, center aligned, medium or large (the medium/large variants do not collapse on scroll, since the bar has no scroll behavior wired). title fills the title slot, navigationIcon the leading slot and actions the trailing slot; the latter two render as empty slots when omitted. The bar itself dispatches no triggers and is not clickable — wire events on the slot tiles (typically IconButtons) instead.