Skip to content

Type to search the docs, or jump to:

v0.9.1 Basic Catalog Guide

Reference Catalog

The Basic Catalog is an optional, styleable reference catalog included for convenience (v0.9.1 supersedes v0.9 while keeping the v0_9 catalog URI). Applications can style these components to match their own design system or define custom domain-specific catalogs; see How to Define a Catalog and the basic_catalog.json schema.

This guide is designed for renderer and client developers implementing the A2UI Basic Catalog (v0.9). It details how to visually present and functionally implement each component and client-side function defined in the catalog.

When building your framework-specific adapters (Layer 3) over the generic A2UI bindings, refer to this document for the expected visual behaviors, suggested layouts, and interaction patterns. This guide uses generic terminology applicable to Web, Mobile (iOS/Android), and Desktop platforms.


1. Components

Text

Displays text content.

Rendering Guidelines: Text should be rendered using a Markdown parser when possible. If markdown rendering is unavailable or fails, gracefully fallback to rendering the raw text. In such cases, renderers should ideally attempt to strip common Markdown markers (like ** or #) to ensure the text remains legible and aesthetically consistent with the intended presentation. Property Mapping:

  • variant="h1" through h5": Apply heading styling. Suggested relative font sizes: h1 (2.5x base), h2 (2x base), h3 (1.75x base), h4 (1.5x base), h5 (1.25x base).
  • variant="caption": Render as smaller text, typically italicized or in a lighter/muted color. Suggested font size: 0.8x base.
  • variant="body" (default): Standard body text. Uses the base font size (e.g., 16dp/16px).

Image

Displays an image from a URL.

Rendering Guidelines: Ensure the component defaults to a flexible width so it fills its container. Property Mapping:

  • fit: Map the property to the platform's equivalent content scaling mode (e.g., CSS object-fit, iOS contentMode, Android ScaleType).
  • variant="icon": Render very small and square (e.g., 24x24dp).
  • variant="avatar": Render small and rounded/circular (e.g., 40x40dp, fully rounded corners).
  • variant="smallFeature": Render as a small rectangle (e.g., 100x100dp).
  • variant="mediumFeature" (default): Render as a medium rectangle (e.g., 100% width up to 300dp, or 200x200dp).
  • variant="largeFeature": Render as a large prominent image (e.g., 100% width, max height 400dp).
  • variant="header": Render as a full-width banner image, usually at the top of a surface (e.g., 100% width, height 200dp, scaling mode set to cover/crop).

Icon

Displays a standard system icon.

Rendering Guidelines: Map the icon name to a system or bundled icon set (e.g., Material Symbols, SF Symbols). The string name from the data model (e.g., accountCircle) should be converted to the required format (like snake_case account_circle) if required by the icon engine. Suggested styling: 24dp size and inherit the current text color.

Video

A video player.

Rendering Guidelines: Render using a native video player component with user controls enabled. Ensure the video container spans the full width of the parent's container for responsiveness. Scrubbing (seeking) should be supported if provided by the native control.

AudioPlayer

An audio player.

Rendering Guidelines: Render using a native audio player component with user controls enabled. Like video, its container should span the full width of its parent. Scrubbing (seeking) should be supported if provided by the native control.

Media URLs (Image, Video, AudioPlayer)

Security Constraints & Implementation Requirements (Mandatory): Image.url, Video.url and AudioPlayer.url come from the agent. To keep them from running script (javascript: in a web renderer) or reading local and app-private resources (file:, content:, blob:, ftp:), every renderer validates them the same way, so a surface loads the same media on every platform:

  1. Trim First: Remove leading and trailing whitespace and control characters before validating. An empty result is rejected.
  2. Enforce Scheme Allowlist: Accept only http:, https: and data: URLs, and relative paths. Reject any other scheme by rendering nothing (or the platform's empty placeholder) for that media, rather than raising an error.
  3. Require scheme:// for HTTP: Accept an http: or https: URL only when it is written with // and a non-empty host (https://host/...). Reject forms such as https:host, which browsers resolve against the page.
  4. Keep Relative Paths on the Same Host: Reject a relative path that starts with two slashes (//host), counting \ as /, because it points at another host. Check the scheme and the leading slashes after dropping tab, newline and carriage-return characters, as browser URL parsers do, so ht\ttps://host and /\t/host are rejected too.
  5. Validate Cheaply: Validation can run on every render, and a data: URL can be megabytes long, so inspect only the scheme prefix and the first characters instead of copying the whole string.

Row

A horizontal layout container.

Rendering Guidelines: Implemented using a horizontal layout container (e.g., CSS Flexbox row, Compose Row, SwiftUI HStack). Ensure it fills the available width. Property Mapping:

  • justify: Maps to main-axis alignment (e.g., justify-content in CSS, horizontalArrangement in Compose). Use equivalents for pushing items to edges (spaceBetween) or packing them together (start, center, end).
  • align: Maps to cross-axis alignment (e.g., align-items in CSS, verticalAlignment in Compose). Use equivalents for top (start), center, or bottom (end).

Column

A vertical layout container.

Rendering Guidelines: Implemented using a vertical layout container (e.g., CSS Flexbox column, Compose Column, SwiftUI VStack). Property Mapping:

  • justify: Maps to main-axis alignment on the vertical axis.
  • align: Maps to cross-axis alignment on the horizontal axis.

List

A scrollable list of components.

Rendering Guidelines: Children of a horizontal list should typically have a constrained max-width so they do not stretch indefinitely. Property Mapping:

  • direction="vertical" (default): Implement as a vertically scrollable view (e.g., CSS overflow-y: auto, Compose LazyColumn, SwiftUI ScrollView vertical).
  • direction="horizontal": Implement as a horizontally scrollable view. Hide the scrollbar for a cleaner look if supported by the platform.

Card

A container with card-like styling that visually groups its child.

Rendering Guidelines: Applies a background color distinct from the main surface, rounded corners (e.g., 8dp or 12dp), a subtle shadow or elevation, and inner padding (e.g., 16dp). Note that the card accepts exactly one child. If the user wants multiple elements inside a card, they must provide a container (like Column) as the single child.

Tabs

A set of tabs, each with a title and a corresponding child component.

Rendering Guidelines: Render a horizontal row of interactive tab headers for the titles. Visually indicate the active tab (e.g., bold text, colored bottom border). Behavior & State: Maintain a local selectedIndex state (defaulting to 0). When a tab header is tapped, update selectedIndex and render only the child component that corresponds to that index.

Divider

A dividing line to separate content.

Property Mapping:

  • axis="horizontal" (default): Render a 1dp tall line spanning 100% width with a subtle border/outline color.
  • axis="vertical": Render a 1dp wide line with a set height, spanning the height of the container.

A dialog window.

Rendering Guidelines:

  • Desktop UIs: Render as a centered popup or native dialog window over the main content, typically with a dimmed backdrop.
  • Mobile UIs: Render as a bottom sheet or full-screen dialog over the main content.
  • You must provide a mechanism to close the modal (e.g., an "X" button, clicking/tapping the backdrop overlay, or a swipe-to-dismiss gesture).

Behavior & State: This component behaves differently than a standard container. It acts as a Modal Entry Point. When instantiated, the user only sees the trigger child component on the screen (which usually acts and looks like a Button). The modal logic intercepts interactions (taps/clicks) on the trigger. When the trigger is tapped, the modal opens and displays the content child component.

Button

An interactive button that dispatches a protocol action.

Rendering Guidelines: Render as a native interactive button component. It must render its child component inside the button (usually a Text or Icon). Behavior & State: When tapped, it dispatches the action back to the server, dynamically resolving the context variables at the moment of the interaction. Property Mapping:

  • variant="default": Standard button with a subtle background and border.
  • variant="primary": Prominent call-to-action button using the theme's primaryColor for its background, and contrasting text.
  • variant="borderless": Button with no background or border, appearing like a clickable text link.

TextField

A field for user text input.

Rendering Guidelines: Render using the platform's native text input control. Behavior & State: Establishes Two-Way Binding. As the user types, immediately write the new string back to the local data model path bound to value. Property Mapping:

  • variant="shortText" (default): Standard single-line input field.
  • variant="longText": Render as a multi-line text area.
  • variant="number": Render as a numeric input field, typically showing a numeric keyboard on mobile.
  • variant="obscured": Render as an obscured password/secure field.

CheckBox

A toggleable control with a label.

Rendering Guidelines: Render a native checkbox or toggle switch component alongside a text label. Behavior & State: Triggers two-way binding on the value path, setting it to boolean true or false when interacted with.

ChoicePicker

A component for selecting one or more options from a list.

Rendering Guidelines:

  • displayStyle="checkbox" (default): Render as a dropdown menu, picker wheel, or an expanding vertical list of selectable options. A dropdown wrapper is preferred to save space.
  • displayStyle="chips": Render as a horizontal, wrapping row of selectable chips/pills. Selected chips should have a distinct background/border.
  • If filterable is true, render a text input above the list of options. As the user types, filter the visible options using a case-insensitive substring match on the option labels.

Behavior & State: Binds to an array of strings in the data model representing the active selections. Toggle selections in the data model upon user interaction.

Slider

A control for selecting a numeric value within a range.

Rendering Guidelines: Render using the platform's native slider or seek bar component. Optionally display the current numeric value next to the slider track. Behavior & State: Set min and max limits. Perform two-way binding, updating the numeric value path as the user drags the slider. Note that the value is a number rather than an integer, allowing for decimal ranges (e.g., 0.0 to 1.0).

DateTimeInput

An input for date and/or time.

Rendering Guidelines: Render using native date and time picker controls.

  • If enableDate and enableTime are both true, show both date and time selection UI.
  • If only enableDate is true, show only a date picker.
  • If only enableTime is true, show only a time picker.

Behavior & State: The component must convert the platform's native date/time format into a standard ISO 8601 string before writing it to the A2UI data model, and correctly parse ISO 8601 strings coming from the model into the input field.


2. Client-Side Functions

Functions provide client-side logic for validation, interpolation, and operations. As defined in the Architecture Guide, the reactivity of function arguments is generally handled by the Core Data Layer (specifically the Binder/Context layer).

Core libraries for each language (such as @a2ui/web_core for TypeScript) typically provide a complete, framework-agnostic implementation of all the functions in the basic catalog. Developers are encouraged to utilize these shared implementations rather than writing their own. When a function is called, the system resolves its arguments. If an argument is a static value, it is passed directly. If it is a dynamic binding, the Context layer handles the subscription. For most standard functions, the execute implementation simply receives a dictionary of static args and returns a static value. The Context layer wraps this execution in a reactive stream (e.g., a computed signal) so that the function re-runs whenever any of its dynamic arguments change.

However, complex functions like formatString must manually interact with the Context to parse and subscribe to nested dynamic dependencies.

formatString

Description: The core interpolation engine. Parses the args.value string for ${expression} blocks, combining literal strings, data paths, and other client-side function results.

Architecture & Logic: Because formatString contains dynamic expressions embedded within a string literal, the Context layer cannot pre-resolve them. The implementation must parse the string and manually create a reactive output.

  1. Parser/Scanner: Implement a parser that scans the input string (args.value) for ${...} blocks. It must properly handle escaped markers (\${) which resolve to a literal ${.
  2. Expression Evaluation: Inside the interpolation block, the parser must differentiate between:
    • Literals: Quoted strings ('...' or "..."), numbers, and keywords (true, false, null).
    • Data Paths: Identifiers starting with a slash (/absolute/path) or relative identifiers (relative/path).
    • Function Calls: Identifiers followed by parentheses, e.g., funcName(argName: value).
  3. Context Resolution: For every parsed DataPath or FunctionCall token, use the DataContext (e.g., context.resolveSignal(token)) to turn it into a reactive stream/signal.
  4. Reactive Return: The function MUST return a computed reactive stream (e.g., a computed(() => ...) signal). Inside this computed stream, unwrap all the resolved signals, convert them to strings, and concatenate them with the literal string parts.

required

Description: Validates that a given value is present.

Logic: Return true if args.value is strictly not null, not undefined, not an empty string "", and not an empty array []. Otherwise, return false.

regex

Description: Validates a value against a regular expression.

Logic: Instantiate a regular expression using args.pattern. Test the args.value string against it. Return true if it matches, false otherwise.

length

Description: Validates string length constraints.

Logic: Ensure the length of the string args.value is >= args.min (if min is provided) and <= args.max (if max is provided).

numeric

Description: Validates numeric range constraints.

Logic: Parse args.value as a number. Ensure it is >= args.min (if min is provided) and <= args.max (if max is provided). Return true if valid, false if invalid or if it cannot be parsed as a number.

email

Description: Validates an email address.

Logic: Test args.value against a standard email regex pattern (e.g., /^[^\s@]+@[^\s@]+\.[^\s@]+$/).

formatNumber

Description: Formats a numeric value.

Logic: Use the platform's native locale formatting (e.g., Intl.NumberFormat on the web or NumberFormatter natively) on args.value.

  • If args.decimals is provided, force both the minimum and maximum fraction digits to that value.
  • Enable grouping (e.g., thousands separators) unless args.grouping is explicitly set to false.

formatCurrency

Description: Formats a number as a currency string.

Logic: Similar to formatNumber, but configured for currency style formatting. Apply the ISO 4217 currency code provided in args.currency (e.g., 'USD', 'EUR').

formatDate

Description: Formats a timestamp into a date string.

Logic: Parse args.value into a native Date/Time object. Interpret the Unicode TR35 args.format string (e.g., yyyy-MM-dd, HH:mm) and construct the formatted date string. You will likely need a platform-specific date formatting library to parse the TR35 pattern.

pluralize

Description: Returns a localized pluralized string.

Logic: Resolve the plural category for the numeric args.value based on the current locale (e.g., using Intl.PluralRules on the web). Map the resulting category (zero, one, two, few, many, other) to the corresponding string provided in the args object. If the specific category string is missing from args, fallback to args.other.

openUrl

Description: Opens a URL.

Logic: Open args.url using the native platform's URL handler (e.g., opening in the system browser or deep-linking to an app). This function returns void and is executed as a side-effect.

Security Constraints & Implementation Requirements (Mandatory): To prevent DOM-Based Cross-Site Scripting (XSS) via javascript:, data:, or other non-HTTP schemes:

  1. Resolve Relative URLs: Before validation, resolve relative paths against the current environment context (e.g., window.location.href in browsers) using standard URL parsing.
  2. Enforce Scheme Allowlist: Strictly validate that the resolved URL protocol/scheme is either https: or http:. Throw an execution or runtime error (such as A2uiExpressionError) and abort the action if any other scheme is used.
  3. Tab-Nabbing Protection: When opening URLs in a new browser window/tab, always supply security attributes: noopener,noreferrer (e.g. window.open(url, '_blank', 'noopener,noreferrer')).

and

Description: Logical AND operator.

Logic: Iterate through the boolean array args.values. Return true only if all values are true. Short-circuit evaluation is encouraged.

or

Description: Logical OR operator.

Logic: Iterate through the boolean array args.values. Return true if at least one value is true. Short-circuit evaluation is encouraged.

not

Description: Logical NOT operator.

Logic: Return the strict boolean negation of args.value.


3. Layout Spacing: Margins and Padding

A common challenge in dynamic UI frameworks is preventing "spacing multiplication," where nested containers (e.g., a Text inside a Row inside a Column) result in accumulated empty space that throws off the design.

To achieve a clean, consistent default spacing where elements feel naturally separated without stacking empty space, implementers should follow a Leaf-Margin Strategy:

  1. Invisible Containers have ZERO Spacing: Structural, invisible layout containers (Row, Column, List) should have no internal padding and no external margins. They act purely as structural boundaries. This guarantees that wrapping an element in a Row or Column does not alter its spacing.
  2. Leaf Components carry the Margin: All non-container, visual "leaf" elements (Text, Image, Icon, Video, AudioPlayer, Slider, etc.) should have a uniform default external margin applied to them (e.g., 8dp on all sides).
  3. Visually Outlined Containers carry the Margin: Containers and inputs that have a visible boundary (Card, Button, TextField, CheckBox, ChoicePicker) should also apply this same uniform default external margin.
    • Note: These elements will naturally also need internal padding to keep their content away from their own visible borders, but this padding is localized and does not affect the external layout.

Why use Margins on Leaves? Applying margins directly to the visual elements—rather than relying on padding or gap properties on the parent containers—ensures predictable spacing. For example, if you have Row(Item1, Item2), using margins on the items guarantees that there is space to the left of Item1, space to the right of Item2, and space between them. Because the invisible containers themselves contribute zero extra spacing, you can deeply nest your structural rows and columns without the spacing unexpectedly multiplying.


4. Color, Contrast, and Nesting

A common challenge in dynamically generated UI is ensuring proper contrast and visual hierarchy when components are nested. For example:

  • A Text or Icon nested inside a primary Button must change its color to contrast with the button's background.
  • A Card nested inside another Card should remain visually distinct.

To keep the A2UI rendering layer simple and performant, do not manually calculate or pass color properties down the A2UI component tree. Instead, rely entirely on the native context and theme inheritance mechanisms provided by your target UI framework.

Text and Icon Contrast

When an element defines a strong background color (like a primary Button using the theme's primaryColor), it must also define the expected text color for its content. It should propagate this expectation implicitly.

  • Web (CSS): The Button wrapper sets the standard CSS color property. Because color is inherited in CSS, any Text or Icon component rendered inside the button will automatically adapt.
  • Compose (Android): The button wrapper should use CompositionLocalProvider(LocalContentColor provides ...). Any nested Text and Icon components will automatically pick up this color without needing it explicitly passed to their A2UI classes.
  • SwiftUI (iOS): Apply .foregroundColor(...) or .environment(\.colorScheme, ...) to the button wrapper.
  • Flutter: Use DefaultTextStyle.merge() and IconTheme.merge() within the button wrapper. If using standard Material buttons (like ElevatedButton), this is often handled for you automatically.

Rule of Thumb: Leaf components like Text and Icon should never hardcode their colors unless explicitly instructed by a property. They must always inherit from their environment.

Nesting Containers (Cards)

When a Card is nested within another Card, or placed on different background surfaces, it needs to remain distinct. Attempting to alternate surface colors based on depth adds significant complexity to the renderer.

Recommended Approach: Outlines and Transparent Surfaces The simplest, most robust starting approach is to give Card components a transparent background and a visible outline/border (e.g., a 1dp outline matching the theme's outline/border color).

  • By using borders instead of opaque surface colors, nested cards will simply draw an inner boundary within the parent card.
  • This guarantees a clear visual hierarchy regardless of how deeply they are nested, and it requires zero context-passing or depth-tracking in your code.
  • If your design system requires opaque cards, consider using a framework-specific elevation system (e.g., standard Material elevation) which often handles shadow and surface tinting automatically, rather than building custom color-alternation logic into the A2UI adapters.

Catalog schema

basic_catalog.json

A2UI Basic Catalog — Unified catalog of basic A2UI components and functions.

Source: specification/v0_9_1/catalogs/basic/catalog.json ↗ Raw JSON ↗ Permalink$id: https://a2ui.org/specification/v0_9/catalogs/basic/catalog.json
Definitions & properties (36)
basic_catalog.json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://a2ui.org/specification/v0_9/catalogs/basic/catalog.json",
"title": "A2UI Basic Catalog",
"description": "Unified catalog of basic A2UI components and functions.",
"catalogId": "https://a2ui.org/specification/v0_9/catalogs/basic/catalog.json",
"components": {
"Text": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"type": "object",
"properties": {
"component": {
"const": "Text"
},
"text": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "The text content to display. While simple Markdown formatting is supported (i.e. without HTML, images, or links), utilizing dedicated UI components is generally preferred for a richer and more structured presentation."
},
"variant": {
"type": "string",
"description": "A hint for the base text style.",
"enum": ["h1", "h2", "h3", "h4", "h5", "caption", "body"],
"default": "body"
}
},
"required": ["component", "text"]
}
],
"unevaluatedProperties": false
},
"Image": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"type": "object",
"properties": {
"component": {
"const": "Image"
},
"url": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "The URL of the image to display."
},
"description": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "Accessibility text for the image."
},
"fit": {
"type": "string",
"description": "Specifies how the image should be resized to fit its container. This corresponds to the CSS 'object-fit' property.",
"enum": ["contain", "cover", "fill", "none", "scaleDown"],
"default": "fill"
},
"variant": {
"type": "string",
"description": "A hint for the image size and style.",
"enum": ["icon", "avatar", "smallFeature", "mediumFeature", "largeFeature", "header"],
"default": "mediumFeature"
}
},
"required": ["component", "url"]
}
],
"unevaluatedProperties": false
},
"Icon": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"type": "object",
"properties": {
"component": {
"const": "Icon"
},
"name": {
"description": "The name of the icon to display.",
"oneOf": [
{
"type": "string",
"enum": [
"accountCircle",
"add",
"arrowBack",
"arrowForward",
"attachFile",
"calendarToday",
"call",
"camera",
"check",
"close",
"delete",
"download",
"edit",
"event",
"error",
"fastForward",
"favorite",
"favoriteOff",
"folder",
"help",
"home",
"info",
"locationOn",
"lock",
"lockOpen",
"mail",
"menu",
"moreVert",
"moreHoriz",
"notificationsOff",
"notifications",
"pause",
"payment",
"person",
"phone",
"photo",
"play",
"print",
"refresh",
"rewind",
"search",
"send",
"settings",
"share",
"shoppingCart",
"skipNext",
"skipPrevious",
"star",
"starHalf",
"starOff",
"stop",
"upload",
"visibility",
"visibilityOff",
"volumeDown",
"volumeMute",
"volumeOff",
"volumeUp",
"warning"
]
},
{
"type": "object",
"properties": {
"svgPath": {
"type": "string"
}
},
"required": ["svgPath"],
"additionalProperties": false
},
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DataBinding"
}
]
}
},
"required": ["component", "name"]
}
],
"unevaluatedProperties": false
},
"Video": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"type": "object",
"properties": {
"component": {
"const": "Video"
},
"url": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "The URL of the video to display."
}
},
"required": ["component", "url"]
}
],
"unevaluatedProperties": false
},
"AudioPlayer": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"type": "object",
"properties": {
"component": {
"const": "AudioPlayer"
},
"url": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "The URL of the audio to be played."
},
"description": {
"description": "A description of the audio, such as a title or summary.",
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString"
}
},
"required": ["component", "url"]
}
],
"unevaluatedProperties": false
},
"Row": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"type": "object",
"description": "A layout component that arranges its children horizontally. To create a grid layout, nest Columns within this Row.",
"properties": {
"component": {
"const": "Row"
},
"children": {
"description": "Defines the children. Use an array of strings for a fixed set of children, or a template object to generate children from a data list. Children cannot be defined inline, they must be referred to by ID.",
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ChildList"
},
"justify": {
"type": "string",
"description": "Defines the arrangement of children along the main axis (horizontally). Use 'spaceBetween' to push items to the edges, or 'start'/'end'/'center' to pack them together.",
"enum": [
"center",
"end",
"spaceAround",
"spaceBetween",
"spaceEvenly",
"start",
"stretch"
],
"default": "start"
},
"align": {
"type": "string",
"description": "Defines the alignment of children along the cross axis (vertically). This is similar to the CSS 'align-items' property, but uses camelCase values (e.g., 'start').",
"enum": ["start", "center", "end", "stretch"],
"default": "stretch"
}
},
"required": ["component", "children"]
}
],
"unevaluatedProperties": false
},
"Column": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"type": "object",
"description": "A layout component that arranges its children vertically. To create a grid layout, nest Rows within this Column.",
"properties": {
"component": {
"const": "Column"
},
"children": {
"description": "Defines the children. Use an array of strings for a fixed set of children, or a template object to generate children from a data list. Children cannot be defined inline, they must be referred to by ID.",
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ChildList"
},
"justify": {
"type": "string",
"description": "Defines the arrangement of children along the main axis (vertically). Use 'spaceBetween' to push items to the edges (e.g. header at top, footer at bottom), or 'start'/'end'/'center' to pack them together.",
"enum": [
"start",
"center",
"end",
"spaceBetween",
"spaceAround",
"spaceEvenly",
"stretch"
],
"default": "start"
},
"align": {
"type": "string",
"description": "Defines the alignment of children along the cross axis (horizontally). This is similar to the CSS 'align-items' property.",
"enum": ["center", "end", "start", "stretch"],
"default": "stretch"
}
},
"required": ["component", "children"]
}
],
"unevaluatedProperties": false
},
"List": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"type": "object",
"properties": {
"component": {
"const": "List"
},
"children": {
"description": "Defines the children. Use an array of strings for a fixed set of children, or a template object to generate children from a data list.",
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ChildList"
},
"direction": {
"type": "string",
"description": "The direction in which the list items are laid out.",
"enum": ["vertical", "horizontal"],
"default": "vertical"
},
"align": {
"type": "string",
"description": "Defines the alignment of children along the cross axis.",
"enum": ["start", "center", "end", "stretch"],
"default": "stretch"
}
},
"required": ["component", "children"]
}
],
"unevaluatedProperties": false
},
"Card": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"type": "object",
"properties": {
"component": {
"const": "Card"
},
"child": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentId",
"description": "The ID of the single child component to be rendered inside the card. To display multiple elements, you MUST wrap them in a layout component (like Column or Row) and pass that container's ID here. Do NOT pass multiple IDs or a non-existent ID."
}
},
"required": ["component", "child"]
}
],
"unevaluatedProperties": false
},
"Tabs": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"type": "object",
"properties": {
"component": {
"const": "Tabs"
},
"tabs": {
"type": "array",
"description": "An array of objects, where each object defines a tab with a title and a child component.",
"minItems": 1,
"items": {
"type": "object",
"properties": {
"title": {
"description": "The tab title.",
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString"
},
"child": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentId",
"description": "The ID of the child component."
}
},
"required": ["title", "child"],
"additionalProperties": false
}
}
},
"required": ["component", "tabs"]
}
],
"unevaluatedProperties": false
},
"Modal": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"type": "object",
"properties": {
"component": {
"const": "Modal"
},
"trigger": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentId",
"description": "The ID of the component that opens the modal when interacted with (e.g., a button)."
},
"content": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentId",
"description": "The ID of the component to be displayed inside the modal."
}
},
"required": ["component", "trigger", "content"]
}
],
"unevaluatedProperties": false
},
"Divider": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"type": "object",
"properties": {
"component": {
"const": "Divider"
},
"axis": {
"type": "string",
"description": "The orientation of the divider.",
"enum": ["horizontal", "vertical"],
"default": "horizontal"
}
},
"required": ["component"]
}
],
"unevaluatedProperties": false
},
"Button": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/Checkable"
},
{
"type": "object",
"properties": {
"component": {
"const": "Button"
},
"child": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentId",
"description": "The ID of the child component. Use a 'Text' component for a labeled button. Only use an 'Icon' if the requirements explicitly ask for an icon-only button."
},
"variant": {
"type": "string",
"description": "A hint for the button style. If omitted, a default button style is used. 'primary' indicates this is the main call-to-action button. 'borderless' means the button has no visual border or background, making its child content appear like a clickable link.",
"enum": ["default", "primary", "borderless"],
"default": "default"
},
"action": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/Action"
}
},
"required": ["component", "child", "action"]
}
],
"unevaluatedProperties": false
},
"TextField": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/Checkable"
},
{
"type": "object",
"properties": {
"component": {
"const": "TextField"
},
"label": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "The text label for the input field."
},
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "The value of the text field."
},
"variant": {
"type": "string",
"description": "The type of input field to display.",
"enum": ["longText", "number", "shortText", "obscured"],
"default": "shortText"
},
"validationRegexp": {
"type": "string",
"description": "A regular expression used for client-side validation of the input."
}
},
"required": ["component", "label"]
}
],
"unevaluatedProperties": false
},
"CheckBox": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/Checkable"
},
{
"type": "object",
"properties": {
"component": {
"const": "CheckBox"
},
"label": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "The text to display next to the checkbox."
},
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicBoolean",
"description": "The current state of the checkbox (true for checked, false for unchecked)."
}
},
"required": ["component", "label", "value"]
}
],
"unevaluatedProperties": false
},
"ChoicePicker": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/Checkable"
},
{
"type": "object",
"description": "A component that allows selecting one or more options from a list.",
"properties": {
"component": {
"const": "ChoicePicker"
},
"label": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "The label for the group of options."
},
"variant": {
"type": "string",
"description": "A hint for how the choice picker should be displayed and behave.",
"enum": ["multipleSelection", "mutuallyExclusive"],
"default": "mutuallyExclusive"
},
"options": {
"type": "array",
"description": "The list of available options to choose from.",
"items": {
"type": "object",
"properties": {
"label": {
"description": "The text to display for this option.",
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString"
},
"value": {
"type": "string",
"description": "The stable value associated with this option."
}
},
"required": ["label", "value"],
"additionalProperties": false
}
},
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicStringList",
"description": "The list of currently selected values. This should be bound to a string array in the data model."
},
"displayStyle": {
"type": "string",
"description": "The display style of the component.",
"enum": ["checkbox", "chips"],
"default": "checkbox"
},
"filterable": {
"type": "boolean",
"description": "If true, displays a search input to filter the options.",
"default": false
}
},
"required": ["component", "options", "value"]
}
],
"unevaluatedProperties": false
},
"Slider": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/Checkable"
},
{
"type": "object",
"properties": {
"component": {
"const": "Slider"
},
"label": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "The label for the slider."
},
"min": {
"type": "number",
"description": "The minimum value of the slider.",
"default": 0
},
"max": {
"type": "number",
"description": "The maximum value of the slider."
},
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicNumber",
"description": "The current value of the slider."
}
},
"required": ["component", "value", "max"]
}
],
"unevaluatedProperties": false
},
"DateTimeInput": {
"type": "object",
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/ComponentCommon"
},
{
"$ref": "#/$defs/CatalogComponentCommon"
},
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/Checkable"
},
{
"type": "object",
"properties": {
"component": {
"const": "DateTimeInput"
},
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "The selected date and/or time value in ISO 8601 format. If not yet set, initialize with an empty string."
},
"enableDate": {
"type": "boolean",
"description": "If true, allows the user to select a date.",
"default": false
},
"enableTime": {
"type": "boolean",
"description": "If true, allows the user to select a time.",
"default": false
},
"min": {
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString"
},
{
"if": {
"type": "string"
},
"then": {
"oneOf": [
{
"format": "date"
},
{
"format": "time"
},
{
"format": "date-time"
}
]
}
}
],
"description": "The minimum allowed date/time in ISO 8601 format."
},
"max": {
"allOf": [
{
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString"
},
{
"if": {
"type": "string"
},
"then": {
"oneOf": [
{
"format": "date"
},
{
"format": "time"
},
{
"format": "date-time"
}
]
}
}
],
"description": "The maximum allowed date/time in ISO 8601 format."
},
"label": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "The text label for the input field."
}
},
"required": ["component", "value"]
}
],
"unevaluatedProperties": false
}
},
"functions": {
"required": {
"type": "object",
"description": "Checks that the value is not null, undefined, or empty.",
"properties": {
"call": {
"const": "required"
},
"args": {
"type": "object",
"properties": {
"value": {
"description": "The value to check."
}
},
"required": ["value"],
"additionalProperties": false
},
"returnType": {
"const": "boolean"
}
},
"required": ["call", "args"],
"unevaluatedProperties": false
},
"regex": {
"type": "object",
"description": "Checks that the value matches a regular expression string.",
"properties": {
"call": {
"const": "regex"
},
"args": {
"type": "object",
"properties": {
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString"
},
"pattern": {
"type": "string",
"description": "The regex pattern to match against."
}
},
"required": ["value", "pattern"],
"unevaluatedProperties": false
},
"returnType": {
"const": "boolean"
}
},
"required": ["call", "args"],
"unevaluatedProperties": false
},
"length": {
"type": "object",
"description": "Checks string length constraints.",
"properties": {
"call": {
"const": "length"
},
"args": {
"type": "object",
"properties": {
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString"
},
"min": {
"type": "integer",
"minimum": 0,
"description": "The minimum allowed length."
},
"max": {
"type": "integer",
"minimum": 0,
"description": "The maximum allowed length."
}
},
"required": ["value"],
"anyOf": [
{
"required": ["min"]
},
{
"required": ["max"]
}
],
"unevaluatedProperties": false
},
"returnType": {
"const": "boolean"
}
},
"required": ["call", "args"],
"unevaluatedProperties": false
},
"numeric": {
"type": "object",
"description": "Checks numeric range constraints.",
"properties": {
"call": {
"const": "numeric"
},
"args": {
"type": "object",
"properties": {
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicNumber"
},
"min": {
"type": "number",
"description": "The minimum allowed value."
},
"max": {
"type": "number",
"description": "The maximum allowed value."
}
},
"required": ["value"],
"anyOf": [
{
"required": ["min"]
},
{
"required": ["max"]
}
],
"unevaluatedProperties": false
},
"returnType": {
"const": "boolean"
}
},
"required": ["call", "args"],
"unevaluatedProperties": false
},
"email": {
"type": "object",
"description": "Checks that the value is a valid email address.",
"properties": {
"call": {
"const": "email"
},
"args": {
"type": "object",
"properties": {
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString"
}
},
"required": ["value"],
"unevaluatedProperties": false
},
"returnType": {
"const": "boolean"
}
},
"required": ["call", "args"],
"unevaluatedProperties": false
},
"formatString": {
"type": "object",
"description": "Performs string interpolation of data model values and other functions in the catalog functions list and returns the resulting string. The value string can contain interpolated expressions in the `${expression}` format. Supported expression types include: JSON Pointer paths to the data model (e.g., `${/absolute/path}` or `${relative/path}`), and client-side function calls (e.g., `${now()}`). Function arguments must be named (e.g., `${formatDate(value:${/currentDate}, format:'MM-dd')}`). To include a literal `${` sequence, escape it as `\\${`.",
"properties": {
"call": {
"const": "formatString"
},
"args": {
"type": "object",
"properties": {
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString"
}
},
"required": ["value"],
"unevaluatedProperties": false
},
"returnType": {
"const": "string"
}
},
"required": ["call", "args"],
"unevaluatedProperties": false
},
"formatNumber": {
"type": "object",
"description": "Formats a number with the specified grouping and decimal precision.",
"properties": {
"call": {
"const": "formatNumber"
},
"args": {
"type": "object",
"properties": {
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicNumber",
"description": "The number to format."
},
"decimals": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicNumber",
"description": "Optional. The number of decimal places to show. Defaults to 0 or 2 depending on locale."
},
"grouping": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicBoolean",
"description": "Optional. If true, uses locale-specific grouping separators (e.g. '1,000'). If false, returns raw digits (e.g. '1000'). Defaults to true."
}
},
"required": ["value"],
"unevaluatedProperties": false
},
"returnType": {
"const": "string"
}
},
"required": ["call", "args"],
"unevaluatedProperties": false
},
"formatCurrency": {
"type": "object",
"description": "Formats a number as a currency string.",
"properties": {
"call": {
"const": "formatCurrency"
},
"args": {
"type": "object",
"properties": {
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicNumber",
"description": "The monetary amount."
},
"currency": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "The ISO 4217 currency code (e.g., 'USD', 'EUR')."
},
"decimals": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicNumber",
"description": "Optional. The number of decimal places to show. Defaults to 0 or 2 depending on locale."
},
"grouping": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicBoolean",
"description": "Optional. If true, uses locale-specific grouping separators (e.g. '1,000'). If false, returns raw digits (e.g. '1000'). Defaults to true."
}
},
"required": ["currency", "value"],
"unevaluatedProperties": false
},
"returnType": {
"const": "string"
}
},
"required": ["call", "args"],
"unevaluatedProperties": false
},
"formatDate": {
"type": "object",
"description": "Formats a timestamp into a string using a pattern.",
"properties": {
"call": {
"const": "formatDate"
},
"args": {
"type": "object",
"properties": {
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicValue",
"description": "The date to format."
},
"format": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "A Unicode TR35 date pattern string.\n\nToken Reference:\n- Year: 'yy' (26), 'yyyy' (2026)\n- Month: 'M' (1), 'MM' (01), 'MMM' (Jan), 'MMMM' (January)\n- Day: 'd' (1), 'dd' (01), 'E' (Tue), 'EEEE' (Tuesday)\n- Hour (12h): 'h' (1-12), 'hh' (01-12) - requires 'a' for AM/PM\n- Hour (24h): 'H' (0-23), 'HH' (00-23) - Military Time\n- Minute: 'mm' (00-59)\n- Second: 'ss' (00-59)\n- Period: 'a' (AM/PM)\n\nExamples:\n- 'MMM dd, yyyy' -> 'Jan 16, 2026'\n- 'HH:mm' -> '14:30' (Military)\n- 'h:mm a' -> '2:30 PM'\n- 'EEEE, d MMMM' -> 'Friday, 16 January'"
}
},
"required": ["format", "value"],
"unevaluatedProperties": false
},
"returnType": {
"const": "string"
}
},
"required": ["call", "args"],
"unevaluatedProperties": false
},
"pluralize": {
"type": "object",
"description": "Returns a localized string based on the Common Locale Data Repository (CLDR) plural category of the count (zero, one, two, few, many, other). Requires an 'other' fallback. For English, just use 'one' and 'other'.",
"properties": {
"call": {
"const": "pluralize"
},
"args": {
"type": "object",
"properties": {
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicNumber",
"description": "The numeric value used to determine the plural category."
},
"zero": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "String for the 'zero' category (e.g., 0 items)."
},
"one": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "String for the 'one' category (e.g., 1 item)."
},
"two": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "String for the 'two' category (used in Arabic, Welsh, etc.)."
},
"few": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "String for the 'few' category (e.g., small groups in Slavic languages)."
},
"many": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "String for the 'many' category (e.g., large groups in various languages)."
},
"other": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicString",
"description": "The default/fallback string (used for general plural cases)."
}
},
"required": ["value", "other"],
"unevaluatedProperties": false
},
"returnType": {
"const": "string"
}
},
"required": ["call", "args"],
"unevaluatedProperties": false
},
"openUrl": {
"type": "object",
"description": "Opens the specified URL in a browser or handler. This function has no return value.",
"properties": {
"call": {
"const": "openUrl"
},
"args": {
"type": "object",
"properties": {
"url": {
"type": "string",
"format": "uri",
"description": "The URL to open."
}
},
"required": ["url"],
"additionalProperties": false
},
"returnType": {
"const": "void"
}
},
"required": ["call", "args"],
"unevaluatedProperties": false
},
"and": {
"type": "object",
"description": "Performs a logical AND operation on a list of boolean values.",
"properties": {
"call": {
"const": "and"
},
"args": {
"type": "object",
"properties": {
"values": {
"type": "array",
"description": "The list of boolean values to evaluate.",
"items": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicBoolean"
},
"minItems": 2
}
},
"required": ["values"],
"unevaluatedProperties": false
},
"returnType": {
"const": "boolean"
}
},
"required": ["call", "args"],
"unevaluatedProperties": false
},
"or": {
"type": "object",
"description": "Performs a logical OR operation on a list of boolean values.",
"properties": {
"call": {
"const": "or"
},
"args": {
"type": "object",
"properties": {
"values": {
"type": "array",
"description": "The list of boolean values to evaluate.",
"items": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicBoolean"
},
"minItems": 2
}
},
"required": ["values"],
"unevaluatedProperties": false
},
"returnType": {
"const": "boolean"
}
},
"required": ["call", "args"],
"unevaluatedProperties": false
},
"not": {
"type": "object",
"description": "Performs a logical NOT operation on a boolean value.",
"properties": {
"call": {
"const": "not"
},
"args": {
"type": "object",
"properties": {
"value": {
"$ref": "https://a2ui.org/specification/v0_9/common_types.json#/$defs/DynamicBoolean",
"description": "The boolean value to negate."
}
},
"required": ["value"],
"unevaluatedProperties": false
},
"returnType": {
"const": "boolean"
}
},
"required": ["call", "args"],
"unevaluatedProperties": false
}
},
"$defs": {
"CatalogComponentCommon": {
"type": "object",
"properties": {
"weight": {
"type": "number",
"description": "The relative weight of this component within a Row or Column. This is similar to the CSS 'flex-grow' property. Note: this may ONLY be set when the component is a direct descendant of a Row or Column."
}
}
},
"theme": {
"type": "object",
"properties": {
"primaryColor": {
"type": "string",
"description": "The primary brand color used for highlights (e.g., primary buttons, active borders). Renderers may generate variants of this color for different contexts. Format: Hexadecimal code (e.g., '#00BFFF').",
"pattern": "^#[0-9a-fA-F]{6}$"
},
"iconUrl": {
"type": "string",
"format": "uri",
"description": "A URL for an image that identifies the agent or tool associated with the surface."
},
"agentDisplayName": {
"type": "string",
"description": "Text to be displayed next to the surface to identify the agent or tool that created it."
}
},
"additionalProperties": true
},
"anyComponent": {
"oneOf": [
{
"$ref": "#/components/Text"
},
{
"$ref": "#/components/Image"
},
{
"$ref": "#/components/Icon"
},
{
"$ref": "#/components/Video"
},
{
"$ref": "#/components/AudioPlayer"
},
{
"$ref": "#/components/Row"
},
{
"$ref": "#/components/Column"
},
{
"$ref": "#/components/List"
},
{
"$ref": "#/components/Card"
},
{
"$ref": "#/components/Tabs"
},
{
"$ref": "#/components/Modal"
},
{
"$ref": "#/components/Divider"
},
{
"$ref": "#/components/Button"
},
{
"$ref": "#/components/TextField"
},
{
"$ref": "#/components/CheckBox"
},
{
"$ref": "#/components/ChoicePicker"
},
{
"$ref": "#/components/Slider"
},
{
"$ref": "#/components/DateTimeInput"
}
],
"discriminator": {
"propertyName": "component"
}
},
"anyFunction": {
"oneOf": [
{
"$ref": "#/functions/required"
},
{
"$ref": "#/functions/regex"
},
{
"$ref": "#/functions/length"
},
{
"$ref": "#/functions/numeric"
},
{
"$ref": "#/functions/email"
},
{
"$ref": "#/functions/formatString"
},
{
"$ref": "#/functions/formatNumber"
},
{
"$ref": "#/functions/formatCurrency"
},
{
"$ref": "#/functions/formatDate"
},
{
"$ref": "#/functions/pluralize"
},
{
"$ref": "#/functions/openUrl"
},
{
"$ref": "#/functions/and"
},
{
"$ref": "#/functions/or"
},
{
"$ref": "#/functions/not"
}
]
}
}
}