Package-level declarations

Types

Link copied to clipboard
@Serializable
@SerialName(value = "AdaptiveVisibility")
data class AdaptiveVisibilityTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val visibility: TileSchema.Visibility, val widthVisibility: AdaptiveVisibilityTileSchema.WidthVisibility, val heightVisibility: AdaptiveVisibilityTileSchema.HeightVisibility) : TileSchema

Conditionally renders tiles based on the current window size class, read from currentWindowAdaptiveInfoV2(). The children are composed only when both widthVisibility and heightVisibility are satisfied; otherwise nothing is emitted at all — the children are not composed, not merely hidden.

Link copied to clipboard
@Serializable
@SerialName(value = "Box")
data class BoxTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val visibility: TileSchema.Visibility, val alignment: AlignmentSchema.TwoDimensional) : TileSchema

Renders a Compose Box that stacks its tiles on top of each other in declaration order (later children paint above earlier ones), positioning all of them with alignment.

Link copied to clipboard
@Serializable
@SerialName(value = "Card")
data class CardTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val visibility: TileSchema.Visibility, val kind: CardTileSchema.Kind) : TileSchema

Renders a Material 3 card hosting tiles in a ColumnScope. kind picks the composable: Kind.DEFAULTCard, Kind.ELEVATEDElevatedCard, Kind.OUTLINEDOutlinedCard.

Link copied to clipboard
@Serializable
@SerialName(value = "Carousel")
data class CarouselTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val visibility: TileSchema.Visibility, val type: CarouselTileSchema.CarouselTypeSchema, val itemSpacing: Int = 0, val contentPadding: Int = 0, val userScrollEnabled: Boolean = true) : TileSchema

Renders a Material 3 horizontal carousel over tiles, one child per carousel item. type picks the composable:

Link copied to clipboard
@Serializable
@SerialName(value = "Column")
data class ColumnTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val filterChildrenByTerm: String?, val visibility: TileSchema.Visibility, val arrangement: ArrangementSchema.Vertical, val alignment: AlignmentSchema.Horizontal, val scrollable: Boolean = false) : TileSchema

Renders a Compose Column stacking its tiles vertically, spaced by arrangement and aligned horizontally by alignment. When scrollable is true the column gets a verticalScroll modifier — every child is composed eagerly, so prefer LazyColumnTileSchema for long lists.

Link copied to clipboard
@Serializable
@SerialName(value = "FlexBox")
data class FlexBoxTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val filterChildrenByTerm: String?, val visibility: TileSchema.Visibility, val direction: FlexBoxTileSchema.FlexDirectionSchema = FlexDirectionSchema.Row, val justifyContent: FlexBoxTileSchema.FlexJustifyContentSchema = FlexJustifyContentSchema.Start, val alignItems: FlexBoxTileSchema.FlexAlignItemsSchema = FlexAlignItemsSchema.Start, val alignContent: FlexBoxTileSchema.FlexAlignContentSchema = FlexAlignContentSchema.Start, val wrap: FlexBoxTileSchema.FlexWrapSchema = FlexWrapSchema.NoWrap, val columnGap: Int = 0, val rowGap: Int = 0) : TileSchema

Renders a Compose FlexBox (experimental flexbox layout) hosting tiles with CSS-flexbox semantics. Every schema enum maps one-to-one onto the corresponding Compose flex value: direction → main axis and its reversal, justifyContent → distribution along the main axis, alignItems → alignment on the cross axis of a single line, alignContent → distribution of the lines themselves, wrap → whether items wrap. columnGap and rowGap are interpreted as dp.

Link copied to clipboard
@Serializable
@SerialName(value = "FlowRow")
data class FlowRowTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val filterChildrenByTerm: String?, val visibility: TileSchema.Visibility, val horizontalArrangement: ArrangementSchema.Horizontal = ArrangementSchema.Horizontal.Start, val verticalArrangement: ArrangementSchema.Vertical = ArrangementSchema.Vertical.Top, val maxItemsInEachRow: Int = Int.MAX_VALUE) : TileSchema

Renders a Compose FlowRow laying its 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 (defaults to unlimited).

Link copied to clipboard
@Serializable
@SerialName(value = "Grid")
data class GridTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val filterChildrenByTerm: String?, val visibility: TileSchema.Visibility, val columns: SerializableImmutableList<GridTileSchema.GridTrackSchema>, val rows: SerializableImmutableList<GridTileSchema.GridTrackSchema> = persistentListOf(), val columnGap: Int = 0, val rowGap: Int = 0, val flow: GridTileSchema.GridFlowSchema = GridFlowSchema.Row) : TileSchema

Renders a Compose Grid (experimental CSS-grid-like layout) hosting tiles. columns and rows declare the track template, each track being one of: GridTrackSchema.Fixed (dp), GridTrackSchema.Fraction (fraction of the available space), GridTrackSchema.Flexible (fr unit), GridTrackSchema.Auto, GridTrackSchema.MaxContent or GridTrackSchema.MinContent. flow decides whether children are placed row-first or column-first, and columnGap / rowGap are interpreted as dp.

Link copied to clipboard
@Serializable
@SerialName(value = "LazyColumn")
data class LazyColumnTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val filterChildrenByTerm: String?, val visibility: TileSchema.Visibility, val arrangement: ArrangementSchema.Vertical, val alignment: AlignmentSchema.Horizontal, val scrollThreshold: Int? = null, val considerLoadingItemAtEndOnThresholdReached: Boolean = true, val displayScrollbar: Boolean = false) : TileSchema

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, which makes this the tile to use for long or paginated lists.

Link copied to clipboard
@Serializable
@SerialName(value = "LazyRow")
data class LazyRowTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val filterChildrenByTerm: String?, val visibility: TileSchema.Visibility, val arrangement: ArrangementSchema.Horizontal, val alignment: AlignmentSchema.Vertical, val scrollThreshold: Int? = null, val considerLoadingItemAtEndOnThresholdReached: Boolean = true, val displayScrollbar: Boolean = false) : TileSchema

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, which makes this the tile to use for long or paginated horizontal lists.

Link copied to clipboard
@SerialName(value = "LazyTiles")
@Serializable
data class LazyTilesTileSchema(val id: String, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val visibility: TileSchema.Visibility, val tiles: SerializableImmutableList<TileSchema>? = null, val placeholderTiles: SerializableImmutableList<TileSchema>, val failureTiles: SerializableImmutableList<TileSchema>, val isFailureState: Boolean = false, val url: String, val method: HttpMethod, val body: AnySerializable?, val headers: Map<String, String>?) : TileSchema

Renders a Column whose content is fetched from the network at display time: the tile calls url with method, headers and body, expects a JSON array of tile schemas back, and renders them in place of its placeholder.

Link copied to clipboard
@Serializable
@SerialName(value = "Pager")
data class PagerTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val visibility: TileSchema.Visibility, val pageSize: PagerTileSchema.PageSizeSchema = PageSizeSchema.Fill, val pageSpacing: Int = 0, val contentPadding: Int = 0, val beyondViewportPageCount: Int = 0) : TileSchema

Renders a Compose HorizontalPager over tiles, one page per child. pageSize chooses between full-width pages (PageSizeSchema.Fill) and fixed-width pages (PageSizeSchema.Fixed, in dp); pageSpacing and contentPadding are dp values (the padding is horizontal only), and beyondViewportPageCount controls how many off-screen pages stay composed.

Link copied to clipboard
@Serializable
@SerialName(value = "PullToRefresh")
data class PullToRefreshTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val visibility: TileSchema.Visibility, val isRefreshing: Boolean = false) : TileSchema

Renders a Material 3 PullToRefreshBox wrapping tiles, showing the refresh indicator while isRefreshing is true.

Link copied to clipboard
@Serializable
@SerialName(value = "Row")
data class RowTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val filterChildrenByTerm: String?, val visibility: TileSchema.Visibility, val arrangement: ArrangementSchema.Horizontal, val alignment: AlignmentSchema.Vertical, val scrollable: Boolean = false) : TileSchema

Renders a Compose Row laying its tiles out horizontally, spaced by arrangement and aligned vertically by alignment. When scrollable is true the row gets a horizontalScroll modifier — every child is composed eagerly, so prefer LazyRowTileSchema for long lists.

Link copied to clipboard
@Serializable
@SerialName(value = "SelectionContainer")
data class SelectionContainerTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val visibility: TileSchema.Visibility) : TileSchema

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.

Link copied to clipboard
@Serializable
@SerialName(value = "Shimmer")
data class ShimmerTileSchema(val id: String, val tiles: SerializableImmutableList<TileSchema>, val events: SerializableImmutableList<EventSchema>?, val style: StyleSchema, val searchableTerms: SerializableImmutableList<String>?, val visibility: TileSchema.Visibility) : TileSchema

Renders a Box hosting tiles with a continuously animated shimmer applied over its whole subtree (via the compose-shimmer library), the usual way to build a skeleton/loading placeholder out of plain tiles.