@crewai-ts/core 0.1.2 → 0.1.5

package/dist/a2ui-schemas.d.ts

@@ -0,0 +1,3312 @@
+export declare const A2UI_SCHEMAS: {
+    readonly "v0.8": {
+        readonly server_to_client: {
+            readonly title: "A2UI Message Schema";
+            readonly description: "Describes a JSON payload for an A2UI (Agent to UI) message, which is used to dynamically construct and update user interfaces. A message MUST contain exactly ONE of the action properties: 'beginRendering', 'surfaceUpdate', 'dataModelUpdate', or 'deleteSurface'.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly beginRendering: {
+                    readonly type: "object";
+                    readonly description: "Signals the client to begin rendering a surface with a root component and specific styles.";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly surfaceId: {
+                            readonly type: "string";
+                            readonly description: "The unique identifier for the UI surface to be rendered.";
+                        };
+                        readonly catalogId: {
+                            readonly type: "string";
+                            readonly description: "The identifier of the component catalog to use for this surface. If omitted, the client MUST default to the standard catalog for this A2UI version (https://a2ui.org/specification/v0_8/standard_catalog_definition.json).";
+                        };
+                        readonly root: {
+                            readonly type: "string";
+                            readonly description: "The ID of the root component to render.";
+                        };
+                        readonly styles: {
+                            readonly type: "object";
+                            readonly description: "Styling information for the UI.";
+                            readonly additionalProperties: true;
+                        };
+                    };
+                    readonly required: readonly ["root", "surfaceId"];
+                };
+                readonly surfaceUpdate: {
+                    readonly type: "object";
+                    readonly description: "Updates a surface with a new set of components.";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly surfaceId: {
+                            readonly type: "string";
+                            readonly description: "The unique identifier for the UI surface to be updated. If you are adding a new surface this *must* be a new, unique identified that has never been used for any existing surfaces shown.";
+                        };
+                        readonly components: {
+                            readonly type: "array";
+                            readonly description: "A list containing all UI components for the surface.";
+                            readonly minItems: 1;
+                            readonly items: {
+                                readonly type: "object";
+                                readonly description: "Represents a *single* component in a UI widget tree. This component could be one of many supported types.";
+                                readonly additionalProperties: false;
+                                readonly properties: {
+                                    readonly id: {
+                                        readonly type: "string";
+                                        readonly description: "The unique identifier for this component.";
+                                    };
+                                    readonly weight: {
+                                        readonly type: "number";
+                                        readonly description: "The relative weight of this component within a Row or Column. This corresponds to the CSS 'flex-grow' property. Note: this may ONLY be set when the component is a direct descendant of a Row or Column.";
+                                    };
+                                    readonly component: {
+                                        readonly type: "object";
+                                        readonly description: "A wrapper object that MUST contain exactly one key, which is the name of the component type. The value is an object containing the properties for that specific component.";
+                                        readonly additionalProperties: true;
+                                    };
+                                };
+                                readonly required: readonly ["id", "component"];
+                            };
+                        };
+                    };
+                    readonly required: readonly ["surfaceId", "components"];
+                };
+                readonly dataModelUpdate: {
+                    readonly type: "object";
+                    readonly description: "Updates the data model for a surface.";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly surfaceId: {
+                            readonly type: "string";
+                            readonly description: "The unique identifier for the UI surface this data model update applies to.";
+                        };
+                        readonly path: {
+                            readonly type: "string";
+                            readonly description: "An optional path to a location within the data model (e.g., '/user/name'). If omitted, or set to '/', the entire data model will be replaced.";
+                        };
+                        readonly contents: {
+                            readonly type: "array";
+                            readonly description: "An array of data entries. Each entry must contain a 'key' and exactly one corresponding typed 'value*' property.";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly description: "A single data entry. Exactly one 'value*' property should be provided alongside the key.";
+                                readonly additionalProperties: false;
+                                readonly properties: {
+                                    readonly key: {
+                                        readonly type: "string";
+                                        readonly description: "The key for this data entry.";
+                                    };
+                                    readonly valueString: {
+                                        readonly type: "string";
+                                    };
+                                    readonly valueNumber: {
+                                        readonly type: "number";
+                                    };
+                                    readonly valueBoolean: {
+                                        readonly type: "boolean";
+                                    };
+                                    readonly valueMap: {
+                                        readonly description: "Represents a map as an adjacency list.";
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                            readonly description: "One entry in the map. Exactly one 'value*' property should be provided alongside the key.";
+                                            readonly additionalProperties: false;
+                                            readonly properties: {
+                                                readonly key: {
+                                                    readonly type: "string";
+                                                };
+                                                readonly valueString: {
+                                                    readonly type: "string";
+                                                };
+                                                readonly valueNumber: {
+                                                    readonly type: "number";
+                                                };
+                                                readonly valueBoolean: {
+                                                    readonly type: "boolean";
+                                                };
+                                            };
+                                            readonly required: readonly ["key"];
+                                        };
+                                    };
+                                };
+                                readonly required: readonly ["key"];
+                            };
+                        };
+                    };
+                    readonly required: readonly ["contents", "surfaceId"];
+                };
+                readonly deleteSurface: {
+                    readonly type: "object";
+                    readonly description: "Signals the client to delete the surface identified by 'surfaceId'.";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly surfaceId: {
+                            readonly type: "string";
+                            readonly description: "The unique identifier for the UI surface to be deleted.";
+                        };
+                    };
+                    readonly required: readonly ["surfaceId"];
+                };
+            };
+        };
+        readonly client_to_server: {
+            readonly title: "A2UI (Agent to UI) Client-to-Server Event Schema";
+            readonly description: "Describes a JSON payload for a client-to-server event message.";
+            readonly type: "object";
+            readonly minProperties: 1;
+            readonly maxProperties: 1;
+            readonly properties: {
+                readonly userAction: {
+                    readonly type: "object";
+                    readonly description: "Reports a user-initiated action from a component.";
+                    readonly properties: {
+                        readonly name: {
+                            readonly type: "string";
+                            readonly description: "The name of the action, taken from the component's action.name property.";
+                        };
+                        readonly surfaceId: {
+                            readonly type: "string";
+                            readonly description: "The id of the surface where the event originated.";
+                        };
+                        readonly sourceComponentId: {
+                            readonly type: "string";
+                            readonly description: "The id of the component that triggered the event.";
+                        };
+                        readonly timestamp: {
+                            readonly type: "string";
+                            readonly format: "date-time";
+                            readonly description: "An ISO 8601 timestamp of when the event occurred.";
+                        };
+                        readonly context: {
+                            readonly type: "object";
+                            readonly description: "A JSON object containing the key-value pairs from the component's action.context, after resolving all data bindings.";
+                            readonly additionalProperties: true;
+                        };
+                    };
+                    readonly required: readonly ["name", "surfaceId", "sourceComponentId", "timestamp", "context"];
+                };
+                readonly error: {
+                    readonly type: "object";
+                    readonly description: "Reports a client-side error. The content is flexible.";
+                    readonly additionalProperties: true;
+                };
+            };
+            readonly oneOf: readonly [{
+                readonly required: readonly ["userAction"];
+            }, {
+                readonly required: readonly ["error"];
+            }];
+        };
+        readonly standard_catalog_definition: {
+            readonly components: {
+                readonly Text: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly text: {
+                            readonly type: "object";
+                            readonly description: "The text content to display. This can be a literal string or a reference to a value in the data model ('path', e.g., '/doc/title'). 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.";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly literalString: {
+                                    readonly type: "string";
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly usageHint: {
+                            readonly type: "string";
+                            readonly description: "A hint for the base text style.";
+                            readonly enum: readonly ["h1", "h2", "h3", "h4", "h5", "caption", "body"];
+                        };
+                    };
+                    readonly required: readonly ["text"];
+                };
+                readonly Image: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly url: {
+                            readonly type: "object";
+                            readonly description: "The URL of the image to display.";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly literalString: {
+                                    readonly type: "string";
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly fit: {
+                            readonly type: "string";
+                            readonly description: "Specifies how the image should be resized to fit its container.";
+                            readonly enum: readonly ["contain", "cover", "fill", "none", "scale-down"];
+                        };
+                        readonly usageHint: {
+                            readonly type: "string";
+                            readonly description: "A hint for the image size and style.";
+                            readonly enum: readonly ["icon", "avatar", "smallFeature", "mediumFeature", "largeFeature", "header"];
+                        };
+                    };
+                    readonly required: readonly ["url"];
+                };
+                readonly Icon: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly name: {
+                            readonly type: "object";
+                            readonly description: "The name of the icon to display.";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly literalString: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["accountCircle", "add", "arrowBack", "arrowForward", "attachFile", "calendarToday", "call", "camera", "check", "close", "delete", "download", "edit", "event", "error", "favorite", "favoriteOff", "folder", "help", "home", "info", "locationOn", "lock", "lockOpen", "mail", "menu", "moreVert", "moreHoriz", "notificationsOff", "notifications", "payment", "person", "phone", "photo", "print", "refresh", "search", "send", "settings", "share", "shoppingCart", "star", "starHalf", "starOff", "upload", "visibility", "visibilityOff", "warning"];
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                    };
+                    readonly required: readonly ["name"];
+                };
+                readonly Video: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly url: {
+                            readonly type: "object";
+                            readonly description: "The URL of the video to display.";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly literalString: {
+                                    readonly type: "string";
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                    };
+                    readonly required: readonly ["url"];
+                };
+                readonly AudioPlayer: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly url: {
+                            readonly type: "object";
+                            readonly description: "The URL of the audio to be played.";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly literalString: {
+                                    readonly type: "string";
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly description: {
+                            readonly type: "object";
+                            readonly description: "A description of the audio, such as a title or summary.";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly literalString: {
+                                    readonly type: "string";
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                    };
+                    readonly required: readonly ["url"];
+                };
+                readonly Row: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly children: {
+                            readonly type: "object";
+                            readonly description: "Defines the children. Use 'explicitList' for a fixed set of children, or 'template' to generate children from a data list.";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly explicitList: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly template: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: false;
+                                    readonly properties: {
+                                        readonly componentId: {
+                                            readonly type: "string";
+                                        };
+                                        readonly dataBinding: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                    readonly required: readonly ["componentId", "dataBinding"];
+                                };
+                            };
+                        };
+                        readonly distribution: {
+                            readonly type: "string";
+                            readonly enum: readonly ["center", "end", "spaceAround", "spaceBetween", "spaceEvenly", "start"];
+                        };
+                        readonly alignment: {
+                            readonly type: "string";
+                            readonly enum: readonly ["start", "center", "end", "stretch"];
+                        };
+                    };
+                    readonly required: readonly ["children"];
+                };
+                readonly Column: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly children: {
+                            readonly type: "object";
+                            readonly description: "Defines the children. Use 'explicitList' for a fixed set of children, or 'template' to generate children from a data list.";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly explicitList: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly template: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: false;
+                                    readonly properties: {
+                                        readonly componentId: {
+                                            readonly type: "string";
+                                        };
+                                        readonly dataBinding: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                    readonly required: readonly ["componentId", "dataBinding"];
+                                };
+                            };
+                        };
+                        readonly distribution: {
+                            readonly type: "string";
+                            readonly enum: readonly ["start", "center", "end", "spaceBetween", "spaceAround", "spaceEvenly"];
+                        };
+                        readonly alignment: {
+                            readonly type: "string";
+                            readonly enum: readonly ["center", "end", "start", "stretch"];
+                        };
+                    };
+                    readonly required: readonly ["children"];
+                };
+                readonly List: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly children: {
+                            readonly type: "object";
+                            readonly description: "Defines the children. Use 'explicitList' for a fixed set of children, or 'template' to generate children from a data list.";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly explicitList: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly template: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: false;
+                                    readonly properties: {
+                                        readonly componentId: {
+                                            readonly type: "string";
+                                        };
+                                        readonly dataBinding: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                    readonly required: readonly ["componentId", "dataBinding"];
+                                };
+                            };
+                        };
+                        readonly direction: {
+                            readonly type: "string";
+                            readonly enum: readonly ["vertical", "horizontal"];
+                        };
+                        readonly alignment: {
+                            readonly type: "string";
+                            readonly enum: readonly ["start", "center", "end", "stretch"];
+                        };
+                    };
+                    readonly required: readonly ["children"];
+                };
+                readonly Card: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly child: {
+                            readonly type: "string";
+                            readonly description: "The ID of the component to be rendered inside the card.";
+                        };
+                    };
+                    readonly required: readonly ["child"];
+                };
+                readonly Tabs: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly tabItems: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly additionalProperties: false;
+                                readonly properties: {
+                                    readonly title: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly properties: {
+                                            readonly literalString: {
+                                                readonly type: "string";
+                                            };
+                                            readonly path: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                    };
+                                    readonly child: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly required: readonly ["title", "child"];
+                            };
+                        };
+                    };
+                    readonly required: readonly ["tabItems"];
+                };
+                readonly Divider: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly axis: {
+                            readonly type: "string";
+                            readonly enum: readonly ["horizontal", "vertical"];
+                        };
+                    };
+                };
+                readonly Modal: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly entryPointChild: {
+                            readonly type: "string";
+                            readonly description: "The ID of the component that opens the modal when interacted with.";
+                        };
+                        readonly contentChild: {
+                            readonly type: "string";
+                            readonly description: "The ID of the component to be displayed inside the modal.";
+                        };
+                    };
+                    readonly required: readonly ["entryPointChild", "contentChild"];
+                };
+                readonly Button: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly child: {
+                            readonly type: "string";
+                            readonly description: "The ID of the component to display in the button.";
+                        };
+                        readonly primary: {
+                            readonly type: "boolean";
+                            readonly description: "Indicates if this button should be styled as the primary action.";
+                        };
+                        readonly action: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly name: {
+                                    readonly type: "string";
+                                };
+                                readonly context: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly properties: {
+                                            readonly key: {
+                                                readonly type: "string";
+                                            };
+                                            readonly value: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly path: {
+                                                        readonly type: "string";
+                                                    };
+                                                    readonly literalString: {
+                                                        readonly type: "string";
+                                                    };
+                                                    readonly literalNumber: {
+                                                        readonly type: "number";
+                                                    };
+                                                    readonly literalBoolean: {
+                                                        readonly type: "boolean";
+                                                    };
+                                                };
+                                            };
+                                        };
+                                        readonly required: readonly ["key", "value"];
+                                    };
+                                };
+                            };
+                            readonly required: readonly ["name"];
+                        };
+                    };
+                    readonly required: readonly ["child", "action"];
+                };
+                readonly CheckBox: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly label: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly literalString: {
+                                    readonly type: "string";
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly value: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly literalBoolean: {
+                                    readonly type: "boolean";
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                    };
+                    readonly required: readonly ["label", "value"];
+                };
+                readonly TextField: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly label: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly literalString: {
+                                    readonly type: "string";
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly text: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly literalString: {
+                                    readonly type: "string";
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly textFieldType: {
+                            readonly type: "string";
+                            readonly enum: readonly ["date", "longText", "number", "shortText", "obscured"];
+                        };
+                        readonly validationRegexp: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly required: readonly ["label"];
+                };
+                readonly DateTimeInput: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly value: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly literalString: {
+                                    readonly type: "string";
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly enableDate: {
+                            readonly type: "boolean";
+                        };
+                        readonly enableTime: {
+                            readonly type: "boolean";
+                        };
+                    };
+                    readonly required: readonly ["value"];
+                };
+                readonly MultipleChoice: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly selections: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly literalArray: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly options: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly additionalProperties: false;
+                                readonly properties: {
+                                    readonly label: {
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly properties: {
+                                            readonly literalString: {
+                                                readonly type: "string";
+                                            };
+                                            readonly path: {
+                                                readonly type: "string";
+                                            };
+                                        };
+                                    };
+                                    readonly value: {
+                                        readonly type: "string";
+                                    };
+                                };
+                                readonly required: readonly ["label", "value"];
+                            };
+                        };
+                        readonly maxAllowedSelections: {
+                            readonly type: "integer";
+                        };
+                        readonly variant: {
+                            readonly type: "string";
+                            readonly enum: readonly ["checkbox", "chips"];
+                        };
+                        readonly filterable: {
+                            readonly type: "boolean";
+                        };
+                    };
+                    readonly required: readonly ["selections", "options"];
+                };
+                readonly Slider: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly value: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly literalNumber: {
+                                    readonly type: "number";
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                        readonly minValue: {
+                            readonly type: "number";
+                        };
+                        readonly maxValue: {
+                            readonly type: "number";
+                        };
+                    };
+                    readonly required: readonly ["value"];
+                };
+            };
+            readonly styles: {
+                readonly font: {
+                    readonly type: "string";
+                    readonly description: "The primary font for the UI.";
+                };
+                readonly primaryColor: {
+                    readonly type: "string";
+                    readonly description: "The primary UI color as a hexadecimal code (e.g., '#00BFFF').";
+                    readonly pattern: "^#[0-9a-fA-F]{6}$";
+                };
+            };
+        };
+        readonly server_to_client_with_standard_catalog: {
+            readonly title: "A2UI Message Schema";
+            readonly description: "Describes a JSON payload for an A2UI (Agent to UI) message, which is used to dynamically construct and update user interfaces. A message MUST contain exactly ONE of the action properties: 'beginRendering', 'surfaceUpdate', 'dataModelUpdate', or 'deleteSurface'.";
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly beginRendering: {
+                    readonly type: "object";
+                    readonly description: "Signals the client to begin rendering a surface with a root component and specific styles.";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly surfaceId: {
+                            readonly type: "string";
+                            readonly description: "The unique identifier for the UI surface to be rendered.";
+                        };
+                        readonly root: {
+                            readonly type: "string";
+                            readonly description: "The ID of the root component to render.";
+                        };
+                        readonly styles: {
+                            readonly type: "object";
+                            readonly description: "Styling information for the UI.";
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly font: {
+                                    readonly type: "string";
+                                    readonly description: "The primary font for the UI.";
+                                };
+                                readonly primaryColor: {
+                                    readonly type: "string";
+                                    readonly description: "The primary UI color as a hexadecimal code (e.g., '#00BFFF').";
+                                    readonly pattern: "^#[0-9a-fA-F]{6}$";
+                                };
+                            };
+                        };
+                    };
+                    readonly required: readonly ["root", "surfaceId"];
+                };
+                readonly surfaceUpdate: {
+                    readonly type: "object";
+                    readonly description: "Updates a surface with a new set of components.";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly surfaceId: {
+                            readonly type: "string";
+                            readonly description: "The unique identifier for the UI surface to be updated. If you are adding a new surface this *must* be a new, unique identified that has never been used for any existing surfaces shown.";
+                        };
+                        readonly components: {
+                            readonly type: "array";
+                            readonly description: "A list containing all UI components for the surface.";
+                            readonly minItems: 1;
+                            readonly items: {
+                                readonly type: "object";
+                                readonly description: "Represents a *single* component in a UI widget tree. This component could be one of many supported types.";
+                                readonly additionalProperties: false;
+                                readonly properties: {
+                                    readonly id: {
+                                        readonly type: "string";
+                                        readonly description: "The unique identifier for this component.";
+                                    };
+                                    readonly weight: {
+                                        readonly type: "number";
+                                        readonly description: "The relative weight of this component within a Row or Column. This corresponds to the CSS 'flex-grow' property. Note: this may ONLY be set when the component is a direct descendant of a Row or Column.";
+                                    };
+                                    readonly component: {
+                                        readonly type: "object";
+                                        readonly description: "A wrapper object that MUST contain exactly one key, which is the name of the component type (e.g., 'Heading'). The value is an object containing the properties for that specific component.";
+                                        readonly additionalProperties: false;
+                                        readonly properties: {
+                                            readonly Text: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly text: {
+                                                        readonly type: "object";
+                                                        readonly description: "The text content to display. This can be a literal string or a reference to a value in the data model ('path', e.g., '/doc/title'). 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.";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly literalString: {
+                                                                readonly type: "string";
+                                                            };
+                                                            readonly path: {
+                                                                readonly type: "string";
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly usageHint: {
+                                                        readonly type: "string";
+                                                        readonly description: "A hint for the base text style. One of:\n- `h1`: Largest heading.\n- `h2`: Second largest heading.\n- `h3`: Third largest heading.\n- `h4`: Fourth largest heading.\n- `h5`: Fifth largest heading.\n- `caption`: Small text for captions.\n- `body`: Standard body text.";
+                                                        readonly enum: readonly ["h1", "h2", "h3", "h4", "h5", "caption", "body"];
+                                                    };
+                                                };
+                                                readonly required: readonly ["text"];
+                                            };
+                                            readonly Image: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly url: {
+                                                        readonly type: "object";
+                                                        readonly description: "The URL of the image to display. This can be a literal string ('literal') or a reference to a value in the data model ('path', e.g. '/thumbnail/url').";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly literalString: {
+                                                                readonly type: "string";
+                                                            };
+                                                            readonly path: {
+                                                                readonly type: "string";
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly fit: {
+                                                        readonly type: "string";
+                                                        readonly description: "Specifies how the image should be resized to fit its container. This corresponds to the CSS 'object-fit' property.";
+                                                        readonly enum: readonly ["contain", "cover", "fill", "none", "scale-down"];
+                                                    };
+                                                    readonly usageHint: {
+                                                        readonly type: "string";
+                                                        readonly description: "A hint for the image size and style. One of:\n- `icon`: Small square icon.\n- `avatar`: Circular avatar image.\n- `smallFeature`: Small feature image.\n- `mediumFeature`: Medium feature image.\n- `largeFeature`: Large feature image.\n- `header`: Full-width, full bleed, header image.";
+                                                        readonly enum: readonly ["icon", "avatar", "smallFeature", "mediumFeature", "largeFeature", "header"];
+                                                    };
+                                                };
+                                                readonly required: readonly ["url"];
+                                            };
+                                            readonly Icon: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly name: {
+                                                        readonly type: "object";
+                                                        readonly description: "The name of the icon to display. This can be a literal string or a reference to a value in the data model ('path', e.g. '/form/submit').";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly literalString: {
+                                                                readonly type: "string";
+                                                                readonly enum: readonly ["accountCircle", "add", "arrowBack", "arrowForward", "attachFile", "calendarToday", "call", "camera", "check", "close", "delete", "download", "edit", "event", "error", "favorite", "favoriteOff", "folder", "help", "home", "info", "locationOn", "lock", "lockOpen", "mail", "menu", "moreVert", "moreHoriz", "notificationsOff", "notifications", "payment", "person", "phone", "photo", "print", "refresh", "search", "send", "settings", "share", "shoppingCart", "star", "starHalf", "starOff", "upload", "visibility", "visibilityOff", "warning"];
+                                                            };
+                                                            readonly path: {
+                                                                readonly type: "string";
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                                readonly required: readonly ["name"];
+                                            };
+                                            readonly Video: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly url: {
+                                                        readonly type: "object";
+                                                        readonly description: "The URL of the video to display. This can be a literal string or a reference to a value in the data model ('path', e.g. '/video/url').";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly literalString: {
+                                                                readonly type: "string";
+                                                            };
+                                                            readonly path: {
+                                                                readonly type: "string";
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                                readonly required: readonly ["url"];
+                                            };
+                                            readonly AudioPlayer: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly url: {
+                                                        readonly type: "object";
+                                                        readonly description: "The URL of the audio to be played. This can be a literal string ('literal') or a reference to a value in the data model ('path', e.g. '/song/url').";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly literalString: {
+                                                                readonly type: "string";
+                                                            };
+                                                            readonly path: {
+                                                                readonly type: "string";
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly description: {
+                                                        readonly type: "object";
+                                                        readonly description: "A description of the audio, such as a title or summary. This can be a literal string or a reference to a value in the data model ('path', e.g. '/song/title').";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly literalString: {
+                                                                readonly type: "string";
+                                                            };
+                                                            readonly path: {
+                                                                readonly type: "string";
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                                readonly required: readonly ["url"];
+                                            };
+                                            readonly Row: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly children: {
+                                                        readonly type: "object";
+                                                        readonly description: "Defines the children. Use 'explicitList' for a fixed set of children, or 'template' to generate children from a data list.";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly explicitList: {
+                                                                readonly type: "array";
+                                                                readonly items: {
+                                                                    readonly type: "string";
+                                                                };
+                                                            };
+                                                            readonly template: {
+                                                                readonly type: "object";
+                                                                readonly description: "A template for generating a dynamic list of children from a data model list. `componentId` is the component to use as a template, and `dataBinding` is the path to the map of components in the data model. Values in the map will define the list of children.";
+                                                                readonly additionalProperties: false;
+                                                                readonly properties: {
+                                                                    readonly componentId: {
+                                                                        readonly type: "string";
+                                                                    };
+                                                                    readonly dataBinding: {
+                                                                        readonly type: "string";
+                                                                    };
+                                                                };
+                                                                readonly required: readonly ["componentId", "dataBinding"];
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly distribution: {
+                                                        readonly type: "string";
+                                                        readonly description: "Defines the arrangement of children along the main axis (horizontally). This corresponds to the CSS 'justify-content' property.";
+                                                        readonly enum: readonly ["center", "end", "spaceAround", "spaceBetween", "spaceEvenly", "start"];
+                                                    };
+                                                    readonly alignment: {
+                                                        readonly type: "string";
+                                                        readonly description: "Defines the alignment of children along the cross axis (vertically). This corresponds to the CSS 'align-items' property.";
+                                                        readonly enum: readonly ["start", "center", "end", "stretch"];
+                                                    };
+                                                };
+                                                readonly required: readonly ["children"];
+                                            };
+                                            readonly Column: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly children: {
+                                                        readonly type: "object";
+                                                        readonly description: "Defines the children. Use 'explicitList' for a fixed set of children, or 'template' to generate children from a data list.";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly explicitList: {
+                                                                readonly type: "array";
+                                                                readonly items: {
+                                                                    readonly type: "string";
+                                                                };
+                                                            };
+                                                            readonly template: {
+                                                                readonly type: "object";
+                                                                readonly description: "A template for generating a dynamic list of children from a data model list. `componentId` is the component to use as a template, and `dataBinding` is the path to the map of components in the data model. Values in the map will define the list of children.";
+                                                                readonly additionalProperties: false;
+                                                                readonly properties: {
+                                                                    readonly componentId: {
+                                                                        readonly type: "string";
+                                                                    };
+                                                                    readonly dataBinding: {
+                                                                        readonly type: "string";
+                                                                    };
+                                                                };
+                                                                readonly required: readonly ["componentId", "dataBinding"];
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly distribution: {
+                                                        readonly type: "string";
+                                                        readonly description: "Defines the arrangement of children along the main axis (vertically). This corresponds to the CSS 'justify-content' property.";
+                                                        readonly enum: readonly ["start", "center", "end", "spaceBetween", "spaceAround", "spaceEvenly"];
+                                                    };
+                                                    readonly alignment: {
+                                                        readonly type: "string";
+                                                        readonly description: "Defines the alignment of children along the cross axis (horizontally). This corresponds to the CSS 'align-items' property.";
+                                                        readonly enum: readonly ["center", "end", "start", "stretch"];
+                                                    };
+                                                };
+                                                readonly required: readonly ["children"];
+                                            };
+                                            readonly List: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly children: {
+                                                        readonly type: "object";
+                                                        readonly description: "Defines the children. Use 'explicitList' for a fixed set of children, or 'template' to generate children from a data list.";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly explicitList: {
+                                                                readonly type: "array";
+                                                                readonly items: {
+                                                                    readonly type: "string";
+                                                                };
+                                                            };
+                                                            readonly template: {
+                                                                readonly type: "object";
+                                                                readonly description: "A template for generating a dynamic list of children from a data model list. `componentId` is the component to use as a template, and `dataBinding` is the path to the map of components in the data model. Values in the map will define the list of children.";
+                                                                readonly additionalProperties: false;
+                                                                readonly properties: {
+                                                                    readonly componentId: {
+                                                                        readonly type: "string";
+                                                                    };
+                                                                    readonly dataBinding: {
+                                                                        readonly type: "string";
+                                                                    };
+                                                                };
+                                                                readonly required: readonly ["componentId", "dataBinding"];
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly direction: {
+                                                        readonly type: "string";
+                                                        readonly description: "The direction in which the list items are laid out.";
+                                                        readonly enum: readonly ["vertical", "horizontal"];
+                                                    };
+                                                    readonly alignment: {
+                                                        readonly type: "string";
+                                                        readonly description: "Defines the alignment of children along the cross axis.";
+                                                        readonly enum: readonly ["start", "center", "end", "stretch"];
+                                                    };
+                                                };
+                                                readonly required: readonly ["children"];
+                                            };
+                                            readonly Card: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly child: {
+                                                        readonly type: "string";
+                                                        readonly description: "The ID of the component to be rendered inside the card.";
+                                                    };
+                                                };
+                                                readonly required: readonly ["child"];
+                                            };
+                                            readonly Tabs: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly tabItems: {
+                                                        readonly type: "array";
+                                                        readonly description: "An array of objects, where each object defines a tab with a title and a child component.";
+                                                        readonly items: {
+                                                            readonly type: "object";
+                                                            readonly additionalProperties: false;
+                                                            readonly properties: {
+                                                                readonly title: {
+                                                                    readonly type: "object";
+                                                                    readonly description: "The tab title. Defines the value as either a literal value or a path to data model value (e.g. '/options/title').";
+                                                                    readonly additionalProperties: false;
+                                                                    readonly properties: {
+                                                                        readonly literalString: {
+                                                                            readonly type: "string";
+                                                                        };
+                                                                        readonly path: {
+                                                                            readonly type: "string";
+                                                                        };
+                                                                    };
+                                                                };
+                                                                readonly child: {
+                                                                    readonly type: "string";
+                                                                };
+                                                            };
+                                                            readonly required: readonly ["title", "child"];
+                                                        };
+                                                    };
+                                                };
+                                                readonly required: readonly ["tabItems"];
+                                            };
+                                            readonly Divider: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly axis: {
+                                                        readonly type: "string";
+                                                        readonly description: "The orientation of the divider.";
+                                                        readonly enum: readonly ["horizontal", "vertical"];
+                                                    };
+                                                };
+                                            };
+                                            readonly Modal: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly entryPointChild: {
+                                                        readonly type: "string";
+                                                        readonly description: "The ID of the component that opens the modal when interacted with (e.g., a button).";
+                                                    };
+                                                    readonly contentChild: {
+                                                        readonly type: "string";
+                                                        readonly description: "The ID of the component to be displayed inside the modal.";
+                                                    };
+                                                };
+                                                readonly required: readonly ["entryPointChild", "contentChild"];
+                                            };
+                                            readonly Button: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly child: {
+                                                        readonly type: "string";
+                                                        readonly description: "The ID of the component to display in the button, typically a Text component.";
+                                                    };
+                                                    readonly primary: {
+                                                        readonly type: "boolean";
+                                                        readonly description: "Indicates if this button should be styled as the primary action.";
+                                                    };
+                                                    readonly action: {
+                                                        readonly type: "object";
+                                                        readonly description: "The client-side action to be dispatched when the button is clicked. It includes the action's name and an optional context payload.";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly name: {
+                                                                readonly type: "string";
+                                                            };
+                                                            readonly context: {
+                                                                readonly type: "array";
+                                                                readonly items: {
+                                                                    readonly type: "object";
+                                                                    readonly additionalProperties: false;
+                                                                    readonly properties: {
+                                                                        readonly key: {
+                                                                            readonly type: "string";
+                                                                        };
+                                                                        readonly value: {
+                                                                            readonly type: "object";
+                                                                            readonly description: "Defines the value to be included in the context as either a literal value or a path to a data model value (e.g. '/user/name').";
+                                                                            readonly additionalProperties: false;
+                                                                            readonly properties: {
+                                                                                readonly path: {
+                                                                                    readonly type: "string";
+                                                                                };
+                                                                                readonly literalString: {
+                                                                                    readonly type: "string";
+                                                                                };
+                                                                                readonly literalNumber: {
+                                                                                    readonly type: "number";
+                                                                                };
+                                                                                readonly literalBoolean: {
+                                                                                    readonly type: "boolean";
+                                                                                };
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                    readonly required: readonly ["key", "value"];
+                                                                };
+                                                            };
+                                                        };
+                                                        readonly required: readonly ["name"];
+                                                    };
+                                                };
+                                                readonly required: readonly ["child", "action"];
+                                            };
+                                            readonly CheckBox: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly label: {
+                                                        readonly type: "object";
+                                                        readonly description: "The text to display next to the checkbox. Defines the value as either a literal value or a path to data model ('path', e.g. '/option/label').";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly literalString: {
+                                                                readonly type: "string";
+                                                            };
+                                                            readonly path: {
+                                                                readonly type: "string";
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly value: {
+                                                        readonly type: "object";
+                                                        readonly description: "The current state of the checkbox (true for checked, false for unchecked). This can be a literal boolean ('literalBoolean') or a reference to a value in the data model ('path', e.g. '/filter/open').";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly literalBoolean: {
+                                                                readonly type: "boolean";
+                                                            };
+                                                            readonly path: {
+                                                                readonly type: "string";
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                                readonly required: readonly ["label", "value"];
+                                            };
+                                            readonly TextField: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly label: {
+                                                        readonly type: "object";
+                                                        readonly description: "The text label for the input field. This can be a literal string or a reference to a value in the data model ('path, e.g. '/user/name').";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly literalString: {
+                                                                readonly type: "string";
+                                                            };
+                                                            readonly path: {
+                                                                readonly type: "string";
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly text: {
+                                                        readonly type: "object";
+                                                        readonly description: "The value of the text field. This can be a literal string or a reference to a value in the data model ('path', e.g. '/user/name').";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly literalString: {
+                                                                readonly type: "string";
+                                                            };
+                                                            readonly path: {
+                                                                readonly type: "string";
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly textFieldType: {
+                                                        readonly type: "string";
+                                                        readonly description: "The type of input field to display.";
+                                                        readonly enum: readonly ["date", "longText", "number", "shortText", "obscured"];
+                                                    };
+                                                    readonly validationRegexp: {
+                                                        readonly type: "string";
+                                                        readonly description: "A regular expression used for client-side validation of the input.";
+                                                    };
+                                                };
+                                                readonly required: readonly ["label"];
+                                            };
+                                            readonly DateTimeInput: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly value: {
+                                                        readonly type: "object";
+                                                        readonly description: "The selected date and/or time value in ISO 8601 format. This can be a literal string ('literalString') or a reference to a value in the data model ('path', e.g. '/user/dob').";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly literalString: {
+                                                                readonly type: "string";
+                                                            };
+                                                            readonly path: {
+                                                                readonly type: "string";
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly enableDate: {
+                                                        readonly type: "boolean";
+                                                        readonly description: "If true, allows the user to select a date.";
+                                                    };
+                                                    readonly enableTime: {
+                                                        readonly type: "boolean";
+                                                        readonly description: "If true, allows the user to select a time.";
+                                                    };
+                                                };
+                                                readonly required: readonly ["value"];
+                                            };
+                                            readonly MultipleChoice: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly selections: {
+                                                        readonly type: "object";
+                                                        readonly description: "The currently selected values for the component. This can be a literal array of strings or a path to an array in the data model('path', e.g. '/hotel/options').";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly literalArray: {
+                                                                readonly type: "array";
+                                                                readonly items: {
+                                                                    readonly type: "string";
+                                                                };
+                                                            };
+                                                            readonly path: {
+                                                                readonly type: "string";
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly options: {
+                                                        readonly type: "array";
+                                                        readonly description: "An array of available options for the user to choose from.";
+                                                        readonly items: {
+                                                            readonly type: "object";
+                                                            readonly additionalProperties: false;
+                                                            readonly properties: {
+                                                                readonly label: {
+                                                                    readonly type: "object";
+                                                                    readonly description: "The text to display for this option. This can be a literal string or a reference to a value in the data model (e.g. '/option/label').";
+                                                                    readonly additionalProperties: false;
+                                                                    readonly properties: {
+                                                                        readonly literalString: {
+                                                                            readonly type: "string";
+                                                                        };
+                                                                        readonly path: {
+                                                                            readonly type: "string";
+                                                                        };
+                                                                    };
+                                                                };
+                                                                readonly value: {
+                                                                    readonly type: "string";
+                                                                    readonly description: "The value to be associated with this option when selected.";
+                                                                };
+                                                            };
+                                                            readonly required: readonly ["label", "value"];
+                                                        };
+                                                    };
+                                                    readonly maxAllowedSelections: {
+                                                        readonly type: "integer";
+                                                        readonly description: "The maximum number of options that the user is allowed to select.";
+                                                    };
+                                                    readonly variant: {
+                                                        readonly type: "string";
+                                                        readonly enum: readonly ["checkbox", "chips"];
+                                                        readonly description: "The visual variant for the selection UI.";
+                                                    };
+                                                    readonly filterable: {
+                                                        readonly type: "boolean";
+                                                        readonly description: "Whether options can be filtered by typing.";
+                                                    };
+                                                };
+                                                readonly required: readonly ["selections", "options"];
+                                            };
+                                            readonly Slider: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly value: {
+                                                        readonly type: "object";
+                                                        readonly description: "The current value of the slider. This can be a literal number ('literalNumber') or a reference to a value in the data model ('path', e.g. '/restaurant/cost').";
+                                                        readonly additionalProperties: false;
+                                                        readonly properties: {
+                                                            readonly literalNumber: {
+                                                                readonly type: "number";
+                                                            };
+                                                            readonly path: {
+                                                                readonly type: "string";
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly minValue: {
+                                                        readonly type: "number";
+                                                        readonly description: "The minimum value of the slider.";
+                                                    };
+                                                    readonly maxValue: {
+                                                        readonly type: "number";
+                                                        readonly description: "The maximum value of the slider.";
+                                                    };
+                                                };
+                                                readonly required: readonly ["value"];
+                                            };
+                                        };
+                                    };
+                                };
+                                readonly required: readonly ["id", "component"];
+                            };
+                        };
+                    };
+                    readonly required: readonly ["surfaceId", "components"];
+                };
+                readonly dataModelUpdate: {
+                    readonly type: "object";
+                    readonly description: "Updates the data model for a surface.";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly surfaceId: {
+                            readonly type: "string";
+                            readonly description: "The unique identifier for the UI surface this data model update applies to.";
+                        };
+                        readonly path: {
+                            readonly type: "string";
+                            readonly description: "An optional path to a location within the data model (e.g., '/user/name'). If omitted, or set to '/', the entire data model will be replaced.";
+                        };
+                        readonly contents: {
+                            readonly type: "array";
+                            readonly description: "An array of data entries. Each entry must contain a 'key' and exactly one corresponding typed 'value*' property.";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly description: "A single data entry. Exactly one 'value*' property should be provided alongside the key.";
+                                readonly additionalProperties: false;
+                                readonly properties: {
+                                    readonly key: {
+                                        readonly type: "string";
+                                        readonly description: "The key for this data entry.";
+                                    };
+                                    readonly valueString: {
+                                        readonly type: "string";
+                                    };
+                                    readonly valueNumber: {
+                                        readonly type: "number";
+                                    };
+                                    readonly valueBoolean: {
+                                        readonly type: "boolean";
+                                    };
+                                    readonly valueMap: {
+                                        readonly description: "Represents a map as an adjacency list.";
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                            readonly description: "One entry in the map. Exactly one 'value*' property should be provided alongside the key.";
+                                            readonly additionalProperties: false;
+                                            readonly properties: {
+                                                readonly key: {
+                                                    readonly type: "string";
+                                                };
+                                                readonly valueString: {
+                                                    readonly type: "string";
+                                                };
+                                                readonly valueNumber: {
+                                                    readonly type: "number";
+                                                };
+                                                readonly valueBoolean: {
+                                                    readonly type: "boolean";
+                                                };
+                                            };
+                                            readonly required: readonly ["key"];
+                                        };
+                                    };
+                                };
+                                readonly required: readonly ["key"];
+                            };
+                        };
+                    };
+                    readonly required: readonly ["contents", "surfaceId"];
+                };
+                readonly deleteSurface: {
+                    readonly type: "object";
+                    readonly description: "Signals the client to delete the surface identified by 'surfaceId'.";
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly surfaceId: {
+                            readonly type: "string";
+                            readonly description: "The unique identifier for the UI surface to be deleted.";
+                        };
+                    };
+                    readonly required: readonly ["surfaceId"];
+                };
+            };
+        };
+    };
+    readonly "v0.9": {
+        readonly server_to_client: {
+            readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+            readonly $id: "https://a2ui.org/specification/v0_9/server_to_client.json";
+            readonly title: "A2UI Message Schema";
+            readonly description: "Describes a JSON payload for an A2UI (Agent to UI) message, which is used to dynamically construct and update user interfaces.";
+            readonly type: "object";
+            readonly oneOf: readonly [{
+                readonly $ref: "#/$defs/CreateSurfaceMessage";
+            }, {
+                readonly $ref: "#/$defs/UpdateComponentsMessage";
+            }, {
+                readonly $ref: "#/$defs/UpdateDataModelMessage";
+            }, {
+                readonly $ref: "#/$defs/DeleteSurfaceMessage";
+            }];
+            readonly $defs: {
+                readonly CreateSurfaceMessage: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly version: {
+                            readonly const: "v0.9";
+                        };
+                        readonly createSurface: {
+                            readonly type: "object";
+                            readonly description: "Signals the client to create a new surface and begin rendering it. When this message is sent, the client will expect 'updateComponents' and/or 'updateDataModel' messages for the same surfaceId that define the component tree.";
+                            readonly properties: {
+                                readonly surfaceId: {
+                                    readonly type: "string";
+                                    readonly description: "The unique identifier for the UI surface to be rendered.";
+                                };
+                                readonly catalogId: {
+                                    readonly description: "A string that uniquely identifies this catalog. It is recommended to prefix this with an internet domain that you own, to avoid conflicts e.g. mycompany.com:somecatalog'.";
+                                    readonly type: "string";
+                                };
+                                readonly theme: {
+                                    readonly $ref: "basic_catalog.json#/$defs/theme";
+                                    readonly description: "Theme parameters for the surface (e.g., {'primaryColor': '#FF0000'}). These must validate against the 'theme' schema defined in the catalog.";
+                                };
+                                readonly sendDataModel: {
+                                    readonly type: "boolean";
+                                    readonly description: "If true, the client will send the full data model of this surface in the metadata of every A2A message sent to the server that created the surface. Defaults to false.";
+                                };
+                            };
+                            readonly required: readonly ["surfaceId", "catalogId"];
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly required: readonly ["createSurface", "version"];
+                    readonly additionalProperties: false;
+                };
+                readonly UpdateComponentsMessage: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly version: {
+                            readonly const: "v0.9";
+                        };
+                        readonly updateComponents: {
+                            readonly type: "object";
+                            readonly description: "Updates a surface with a new set of components. This message can be sent multiple times to update the component tree of an existing surface. One of the components in one of the components lists MUST have an 'id' of 'root' to serve as the root of the component tree. The createSurface message MUST have been previously sent with the 'catalogId' that is in this message.";
+                            readonly properties: {
+                                readonly surfaceId: {
+                                    readonly type: "string";
+                                    readonly description: "The unique identifier for the UI surface to be updated.";
+                                };
+                                readonly components: {
+                                    readonly type: "array";
+                                    readonly description: "A list containing all UI components for the surface.";
+                                    readonly minItems: 1;
+                                    readonly items: {
+                                        readonly $ref: "basic_catalog.json#/$defs/anyComponent";
+                                    };
+                                };
+                            };
+                            readonly required: readonly ["surfaceId", "components"];
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly required: readonly ["updateComponents", "version"];
+                    readonly additionalProperties: false;
+                };
+                readonly UpdateDataModelMessage: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly version: {
+                            readonly const: "v0.9";
+                        };
+                        readonly updateDataModel: {
+                            readonly type: "object";
+                            readonly description: "Updates the data model for an existing surface. This message can be sent multiple times to update the data model. The createSurface message MUST have been previously sent with the 'catalogId' that is in this message.";
+                            readonly properties: {
+                                readonly surfaceId: {
+                                    readonly type: "string";
+                                    readonly description: "The unique identifier for the UI surface this data model update applies to.";
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                    readonly description: "An optional path to a location within the data model (e.g., '/user/name'). If omitted, or set to '/', refers to the entire data model.";
+                                };
+                                readonly value: {
+                                    readonly description: "The data to be updated in the data model. If present, the value at 'path' is replaced (or created). If omitted, the key at 'path' is removed.";
+                                    readonly additionalProperties: true;
+                                };
+                            };
+                            readonly required: readonly ["surfaceId"];
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly required: readonly ["updateDataModel", "version"];
+                    readonly additionalProperties: false;
+                };
+                readonly DeleteSurfaceMessage: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly version: {
+                            readonly const: "v0.9";
+                        };
+                        readonly deleteSurface: {
+                            readonly type: "object";
+                            readonly description: "Signals the client to delete the surface identified by 'surfaceId'. The createSurface message MUST have been previously sent with the 'catalogId' that is in this message.";
+                            readonly properties: {
+                                readonly surfaceId: {
+                                    readonly type: "string";
+                                    readonly description: "The unique identifier for the UI surface to be deleted.";
+                                };
+                            };
+                            readonly required: readonly ["surfaceId"];
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly required: readonly ["deleteSurface", "version"];
+                    readonly additionalProperties: false;
+                };
+            };
+        };
+        readonly client_to_server: {
+            readonly title: "A2UI (Agent to UI) Client-to-Server Event Schema";
+            readonly description: "Describes a JSON payload for a client-to-server event message.";
+            readonly type: "object";
+            readonly minProperties: 2;
+            readonly maxProperties: 2;
+            readonly properties: {
+                readonly version: {
+                    readonly const: "v0.9";
+                };
+                readonly action: {
+                    readonly type: "object";
+                    readonly description: "Reports a user-initiated action from a component.";
+                    readonly properties: {
+                        readonly name: {
+                            readonly type: "string";
+                            readonly description: "The name of the action, taken from the component's action.event.name property.";
+                        };
+                        readonly surfaceId: {
+                            readonly type: "string";
+                            readonly description: "The id of the surface where the event originated.";
+                        };
+                        readonly sourceComponentId: {
+                            readonly type: "string";
+                            readonly description: "The id of the component that triggered the event.";
+                        };
+                        readonly timestamp: {
+                            readonly type: "string";
+                            readonly format: "date-time";
+                            readonly description: "An ISO 8601 timestamp of when the event occurred.";
+                        };
+                        readonly context: {
+                            readonly type: "object";
+                            readonly description: "A JSON object containing the key-value pairs from the component's action.event.context, after resolving all data bindings.";
+                            readonly additionalProperties: true;
+                        };
+                    };
+                    readonly required: readonly ["name", "surfaceId", "sourceComponentId", "timestamp", "context"];
+                };
+                readonly error: {
+                    readonly description: "Reports a client-side error.";
+                    readonly oneOf: readonly [{
+                        readonly type: "object";
+                        readonly title: "Validation Failed Error";
+                        readonly properties: {
+                            readonly code: {
+                                readonly const: "VALIDATION_FAILED";
+                            };
+                            readonly surfaceId: {
+                                readonly type: "string";
+                                readonly description: "The id of the surface where the error occurred.";
+                            };
+                            readonly path: {
+                                readonly type: "string";
+                                readonly description: "The JSON pointer to the field that failed validation (e.g. '/components/0/text').";
+                            };
+                            readonly message: {
+                                readonly type: "string";
+                                readonly description: "A short one or two sentence description of why validation failed.";
+                            };
+                        };
+                        readonly required: readonly ["code", "path", "message", "surfaceId"];
+                        readonly additionalProperties: false;
+                    }, {
+                        readonly type: "object";
+                        readonly title: "Generic Error";
+                        readonly properties: {
+                            readonly code: {
+                                readonly not: {
+                                    readonly const: "VALIDATION_FAILED";
+                                };
+                            };
+                            readonly message: {
+                                readonly type: "string";
+                                readonly description: "A short one or two sentence description of why the error occurred.";
+                            };
+                            readonly surfaceId: {
+                                readonly type: "string";
+                                readonly description: "The id of the surface where the error occurred.";
+                            };
+                        };
+                        readonly required: readonly ["code", "surfaceId", "message"];
+                        readonly additionalProperties: true;
+                    }];
+                };
+            };
+            readonly oneOf: readonly [{
+                readonly required: readonly ["action", "version"];
+            }, {
+                readonly required: readonly ["error", "version"];
+            }];
+        };
+        readonly common_types: {
+            readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+            readonly $id: "https://a2ui.org/specification/v0_9/common_types.json";
+            readonly title: "A2UI Common Types";
+            readonly description: "Common type definitions used across A2UI schemas.";
+            readonly $defs: {
+                readonly ComponentId: {
+                    readonly type: "string";
+                    readonly description: "The unique identifier for a component, used for both definitions and references within the same surface.";
+                };
+                readonly AccessibilityAttributes: {
+                    readonly type: "object";
+                    readonly description: "Attributes to enhance accessibility when using assistive technologies like screen readers.";
+                    readonly properties: {
+                        readonly label: {
+                            readonly $ref: "#/$defs/DynamicString";
+                            readonly description: "A short string, typically 1 to 3 words, used by assistive technologies to convey the purpose or intent of an element. For example, an input field might have an accessible label of 'User ID' or a button might be labeled 'Submit'.";
+                        };
+                        readonly description: {
+                            readonly $ref: "#/$defs/DynamicString";
+                            readonly description: "Additional information provided by assistive technologies about an element such as instructions, format requirements, or result of an action. For example, a mute button might have a label of 'Mute' and a description of 'Silences notifications about this conversation'.";
+                        };
+                    };
+                };
+                readonly ComponentCommon: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly id: {
+                            readonly $ref: "#/$defs/ComponentId";
+                        };
+                        readonly accessibility: {
+                            readonly $ref: "#/$defs/AccessibilityAttributes";
+                        };
+                    };
+                    readonly required: readonly ["id"];
+                };
+                readonly ChildList: {
+                    readonly oneOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly $ref: "#/$defs/ComponentId";
+                        };
+                        readonly description: "A static list of child component IDs.";
+                    }, {
+                        readonly type: "object";
+                        readonly description: "A template for generating a dynamic list of children from a data model list. The `componentId` is the component to use as a template.";
+                        readonly properties: {
+                            readonly componentId: {
+                                readonly $ref: "#/$defs/ComponentId";
+                            };
+                            readonly path: {
+                                readonly type: "string";
+                                readonly description: "The path to the list of component property objects in the data model.";
+                            };
+                        };
+                        readonly required: readonly ["componentId", "path"];
+                        readonly additionalProperties: false;
+                    }];
+                };
+                readonly DataBinding: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly path: {
+                            readonly type: "string";
+                            readonly description: "A JSON Pointer path to a value in the data model.";
+                        };
+                    };
+                    readonly required: readonly ["path"];
+                    readonly additionalProperties: false;
+                };
+                readonly DynamicValue: {
+                    readonly description: "A value that can be a literal, a path, or a function call returning any type.";
+                    readonly oneOf: readonly [{
+                        readonly type: "string";
+                    }, {
+                        readonly type: "number";
+                    }, {
+                        readonly type: "boolean";
+                    }, {
+                        readonly type: "array";
+                    }, {
+                        readonly $ref: "#/$defs/DataBinding";
+                    }, {
+                        readonly $ref: "#/$defs/FunctionCall";
+                    }];
+                };
+                readonly DynamicString: {
+                    readonly description: "Represents a string";
+                    readonly oneOf: readonly [{
+                        readonly type: "string";
+                    }, {
+                        readonly $ref: "#/$defs/DataBinding";
+                    }, {
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/$defs/FunctionCall";
+                        }, {
+                            readonly properties: {
+                                readonly returnType: {
+                                    readonly const: "string";
+                                };
+                            };
+                        }];
+                    }];
+                };
+                readonly DynamicNumber: {
+                    readonly description: "Represents a value that can be either a literal number, a path to a number in the data model, or a function call returning a number.";
+                    readonly oneOf: readonly [{
+                        readonly type: "number";
+                    }, {
+                        readonly $ref: "#/$defs/DataBinding";
+                    }, {
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/$defs/FunctionCall";
+                        }, {
+                            readonly properties: {
+                                readonly returnType: {
+                                    readonly const: "number";
+                                };
+                            };
+                        }];
+                    }];
+                };
+                readonly DynamicBoolean: {
+                    readonly description: "A boolean value that can be a literal, a path, or a function call returning a boolean.";
+                    readonly oneOf: readonly [{
+                        readonly type: "boolean";
+                    }, {
+                        readonly $ref: "#/$defs/DataBinding";
+                    }, {
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/$defs/FunctionCall";
+                        }, {
+                            readonly properties: {
+                                readonly returnType: {
+                                    readonly const: "boolean";
+                                };
+                            };
+                        }];
+                    }];
+                };
+                readonly DynamicStringList: {
+                    readonly description: "Represents a value that can be either a literal array of strings, a path to a string array in the data model, or a function call returning a string array.";
+                    readonly oneOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    }, {
+                        readonly $ref: "#/$defs/DataBinding";
+                    }, {
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/$defs/FunctionCall";
+                        }, {
+                            readonly properties: {
+                                readonly returnType: {
+                                    readonly const: "array";
+                                };
+                            };
+                        }];
+                    }];
+                };
+                readonly FunctionCall: {
+                    readonly type: "object";
+                    readonly description: "Invokes a named function on the client.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly type: "string";
+                            readonly description: "The name of the function to call.";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly description: "Arguments passed to the function.";
+                            readonly additionalProperties: {
+                                readonly anyOf: readonly [{
+                                    readonly $ref: "#/$defs/DynamicValue";
+                                }, {
+                                    readonly type: "object";
+                                    readonly description: "A literal object argument (e.g. configuration).";
+                                }];
+                            };
+                        };
+                        readonly returnType: {
+                            readonly type: "string";
+                            readonly description: "The expected return type of the function call.";
+                            readonly enum: readonly ["string", "number", "boolean", "array", "object", "any", "void"];
+                            readonly default: "boolean";
+                        };
+                    };
+                    readonly required: readonly ["call"];
+                    readonly oneOf: readonly [{
+                        readonly $ref: "basic_catalog.json#/$defs/anyFunction";
+                    }];
+                };
+                readonly CheckRule: {
+                    readonly type: "object";
+                    readonly description: "A single validation rule applied to an input component.";
+                    readonly properties: {
+                        readonly condition: {
+                            readonly $ref: "#/$defs/DynamicBoolean";
+                        };
+                        readonly message: {
+                            readonly type: "string";
+                            readonly description: "The error message to display if the check fails.";
+                        };
+                    };
+                    readonly required: readonly ["condition", "message"];
+                    readonly additionalProperties: false;
+                };
+                readonly Checkable: {
+                    readonly description: "Properties for components that support client-side checks.";
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly checks: {
+                            readonly type: "array";
+                            readonly description: "A list of checks to perform. These are function calls that must return a boolean indicating validity.";
+                            readonly items: {
+                                readonly $ref: "#/$defs/CheckRule";
+                            };
+                        };
+                    };
+                };
+                readonly Action: {
+                    readonly description: "Defines an interaction handler that can either trigger a server-side event or execute a local client-side function.";
+                    readonly oneOf: readonly [{
+                        readonly type: "object";
+                        readonly description: "Triggers a server-side event.";
+                        readonly properties: {
+                            readonly event: {
+                                readonly type: "object";
+                                readonly description: "The event to dispatch to the server.";
+                                readonly properties: {
+                                    readonly name: {
+                                        readonly type: "string";
+                                        readonly description: "The name of the action to be dispatched to the server.";
+                                    };
+                                    readonly context: {
+                                        readonly type: "object";
+                                        readonly description: "A JSON object containing the key-value pairs for the action context. Values can be literals or paths. Use literal values unless the value must be dynamically bound to the data model. Do NOT use paths for static IDs.";
+                                        readonly additionalProperties: {
+                                            readonly $ref: "#/$defs/DynamicValue";
+                                        };
+                                    };
+                                };
+                                readonly required: readonly ["name"];
+                                readonly additionalProperties: false;
+                            };
+                        };
+                        readonly required: readonly ["event"];
+                        readonly additionalProperties: false;
+                    }, {
+                        readonly type: "object";
+                        readonly description: "Executes a local client-side function.";
+                        readonly properties: {
+                            readonly functionCall: {
+                                readonly $ref: "#/$defs/FunctionCall";
+                            };
+                        };
+                        readonly required: readonly ["functionCall"];
+                        readonly additionalProperties: false;
+                    }];
+                };
+            };
+        };
+        readonly basic_catalog: {
+            readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+            readonly $id: "https://a2ui.org/specification/v0_9/basic_catalog.json";
+            readonly title: "A2UI Basic Catalog";
+            readonly description: "Unified catalog of basic A2UI components and functions.";
+            readonly catalogId: "https://a2ui.org/specification/v0_9/basic_catalog.json";
+            readonly components: {
+                readonly Text: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "Text";
+                            };
+                            readonly text: {
+                                readonly $ref: "common_types.json#/$defs/DynamicString";
+                                readonly 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.";
+                            };
+                            readonly variant: {
+                                readonly type: "string";
+                                readonly description: "A hint for the base text style.";
+                                readonly enum: readonly ["h1", "h2", "h3", "h4", "h5", "caption", "body"];
+                                readonly default: "body";
+                            };
+                        };
+                        readonly required: readonly ["component", "text"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly Image: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "Image";
+                            };
+                            readonly url: {
+                                readonly $ref: "common_types.json#/$defs/DynamicString";
+                                readonly description: "The URL of the image to display.";
+                            };
+                            readonly description: {
+                                readonly $ref: "common_types.json#/$defs/DynamicString";
+                                readonly description: "Accessibility text for the image.";
+                            };
+                            readonly fit: {
+                                readonly type: "string";
+                                readonly description: "Specifies how the image should be resized to fit its container. This corresponds to the CSS 'object-fit' property.";
+                                readonly enum: readonly ["contain", "cover", "fill", "none", "scaleDown"];
+                                readonly default: "fill";
+                            };
+                            readonly variant: {
+                                readonly type: "string";
+                                readonly description: "A hint for the image size and style.";
+                                readonly enum: readonly ["icon", "avatar", "smallFeature", "mediumFeature", "largeFeature", "header"];
+                                readonly default: "mediumFeature";
+                            };
+                        };
+                        readonly required: readonly ["component", "url"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly Icon: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "Icon";
+                            };
+                            readonly name: {
+                                readonly description: "The name of the icon to display.";
+                                readonly oneOf: readonly [{
+                                    readonly type: "string";
+                                    readonly enum: readonly ["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"];
+                                }, {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly path: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                    readonly required: readonly ["path"];
+                                    readonly additionalProperties: false;
+                                }];
+                            };
+                        };
+                        readonly required: readonly ["component", "name"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly Video: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "Video";
+                            };
+                            readonly url: {
+                                readonly $ref: "common_types.json#/$defs/DynamicString";
+                                readonly description: "The URL of the video to display.";
+                            };
+                        };
+                        readonly required: readonly ["component", "url"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly AudioPlayer: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "AudioPlayer";
+                            };
+                            readonly url: {
+                                readonly $ref: "common_types.json#/$defs/DynamicString";
+                                readonly description: "The URL of the audio to be played.";
+                            };
+                            readonly description: {
+                                readonly description: "A description of the audio, such as a title or summary.";
+                                readonly $ref: "common_types.json#/$defs/DynamicString";
+                            };
+                        };
+                        readonly required: readonly ["component", "url"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly Row: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly type: "object";
+                        readonly description: "A layout component that arranges its children horizontally. To create a grid layout, nest Columns within this Row.";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "Row";
+                            };
+                            readonly children: {
+                                readonly 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.";
+                                readonly $ref: "common_types.json#/$defs/ChildList";
+                            };
+                            readonly justify: {
+                                readonly type: "string";
+                                readonly 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.";
+                                readonly enum: readonly ["center", "end", "spaceAround", "spaceBetween", "spaceEvenly", "start", "stretch"];
+                                readonly default: "start";
+                            };
+                            readonly align: {
+                                readonly type: "string";
+                                readonly 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').";
+                                readonly enum: readonly ["start", "center", "end", "stretch"];
+                                readonly default: "stretch";
+                            };
+                        };
+                        readonly required: readonly ["component", "children"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly Column: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly type: "object";
+                        readonly description: "A layout component that arranges its children vertically. To create a grid layout, nest Rows within this Column.";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "Column";
+                            };
+                            readonly children: {
+                                readonly 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.";
+                                readonly $ref: "common_types.json#/$defs/ChildList";
+                            };
+                            readonly justify: {
+                                readonly type: "string";
+                                readonly 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.";
+                                readonly enum: readonly ["start", "center", "end", "spaceBetween", "spaceAround", "spaceEvenly", "stretch"];
+                                readonly default: "start";
+                            };
+                            readonly align: {
+                                readonly type: "string";
+                                readonly description: "Defines the alignment of children along the cross axis (horizontally). This is similar to the CSS 'align-items' property.";
+                                readonly enum: readonly ["center", "end", "start", "stretch"];
+                                readonly default: "stretch";
+                            };
+                        };
+                        readonly required: readonly ["component", "children"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly List: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "List";
+                            };
+                            readonly children: {
+                                readonly 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.";
+                                readonly $ref: "common_types.json#/$defs/ChildList";
+                            };
+                            readonly direction: {
+                                readonly type: "string";
+                                readonly description: "The direction in which the list items are laid out.";
+                                readonly enum: readonly ["vertical", "horizontal"];
+                                readonly default: "vertical";
+                            };
+                            readonly align: {
+                                readonly type: "string";
+                                readonly description: "Defines the alignment of children along the cross axis.";
+                                readonly enum: readonly ["start", "center", "end", "stretch"];
+                                readonly default: "stretch";
+                            };
+                        };
+                        readonly required: readonly ["component", "children"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly Card: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "Card";
+                            };
+                            readonly child: {
+                                readonly $ref: "common_types.json#/$defs/ComponentId";
+                                readonly 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. Do NOT define the child component inline.";
+                            };
+                        };
+                        readonly required: readonly ["component", "child"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly Tabs: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "Tabs";
+                            };
+                            readonly tabs: {
+                                readonly type: "array";
+                                readonly description: "An array of objects, where each object defines a tab with a title and a child component.";
+                                readonly minItems: 1;
+                                readonly items: {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly title: {
+                                            readonly description: "The tab title.";
+                                            readonly $ref: "common_types.json#/$defs/DynamicString";
+                                        };
+                                        readonly child: {
+                                            readonly $ref: "common_types.json#/$defs/ComponentId";
+                                            readonly description: "The ID of the child component. Do NOT define the component inline.";
+                                        };
+                                    };
+                                    readonly required: readonly ["title", "child"];
+                                    readonly additionalProperties: false;
+                                };
+                            };
+                        };
+                        readonly required: readonly ["component", "tabs"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly Modal: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "Modal";
+                            };
+                            readonly trigger: {
+                                readonly $ref: "common_types.json#/$defs/ComponentId";
+                                readonly description: "The ID of the component that opens the modal when interacted with (e.g., a button). Do NOT define the component inline.";
+                            };
+                            readonly content: {
+                                readonly $ref: "common_types.json#/$defs/ComponentId";
+                                readonly description: "The ID of the component to be displayed inside the modal. Do NOT define the component inline.";
+                            };
+                        };
+                        readonly required: readonly ["component", "trigger", "content"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly Divider: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "Divider";
+                            };
+                            readonly axis: {
+                                readonly type: "string";
+                                readonly description: "The orientation of the divider.";
+                                readonly enum: readonly ["horizontal", "vertical"];
+                                readonly default: "horizontal";
+                            };
+                        };
+                        readonly required: readonly ["component"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly Button: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly $ref: "common_types.json#/$defs/Checkable";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "Button";
+                            };
+                            readonly child: {
+                                readonly $ref: "common_types.json#/$defs/ComponentId";
+                                readonly 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. Do NOT define the child component inline.";
+                            };
+                            readonly variant: {
+                                readonly type: "string";
+                                readonly 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.";
+                                readonly enum: readonly ["default", "primary", "borderless"];
+                                readonly default: "default";
+                            };
+                            readonly action: {
+                                readonly $ref: "common_types.json#/$defs/Action";
+                            };
+                        };
+                        readonly required: readonly ["component", "child", "action"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly TextField: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly $ref: "common_types.json#/$defs/Checkable";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "TextField";
+                            };
+                            readonly label: {
+                                readonly $ref: "common_types.json#/$defs/DynamicString";
+                                readonly description: "The text label for the input field.";
+                            };
+                            readonly value: {
+                                readonly $ref: "common_types.json#/$defs/DynamicString";
+                                readonly description: "The value of the text field.";
+                            };
+                            readonly variant: {
+                                readonly type: "string";
+                                readonly description: "The type of input field to display.";
+                                readonly enum: readonly ["longText", "number", "shortText", "obscured"];
+                                readonly default: "shortText";
+                            };
+                            readonly validationRegexp: {
+                                readonly type: "string";
+                                readonly description: "A regular expression used for client-side validation of the input.";
+                            };
+                        };
+                        readonly required: readonly ["component", "label"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly CheckBox: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly $ref: "common_types.json#/$defs/Checkable";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "CheckBox";
+                            };
+                            readonly label: {
+                                readonly $ref: "common_types.json#/$defs/DynamicString";
+                                readonly description: "The text to display next to the checkbox.";
+                            };
+                            readonly value: {
+                                readonly $ref: "common_types.json#/$defs/DynamicBoolean";
+                                readonly description: "The current state of the checkbox (true for checked, false for unchecked).";
+                            };
+                        };
+                        readonly required: readonly ["component", "label", "value"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly ChoicePicker: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly $ref: "common_types.json#/$defs/Checkable";
+                    }, {
+                        readonly type: "object";
+                        readonly description: "A component that allows selecting one or more options from a list.";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "ChoicePicker";
+                            };
+                            readonly label: {
+                                readonly $ref: "common_types.json#/$defs/DynamicString";
+                                readonly description: "The label for the group of options.";
+                            };
+                            readonly variant: {
+                                readonly type: "string";
+                                readonly description: "A hint for how the choice picker should be displayed and behave.";
+                                readonly enum: readonly ["multipleSelection", "mutuallyExclusive"];
+                                readonly default: "mutuallyExclusive";
+                            };
+                            readonly options: {
+                                readonly type: "array";
+                                readonly description: "The list of available options to choose from.";
+                                readonly items: {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly label: {
+                                            readonly description: "The text to display for this option.";
+                                            readonly $ref: "common_types.json#/$defs/DynamicString";
+                                        };
+                                        readonly value: {
+                                            readonly type: "string";
+                                            readonly description: "The stable value associated with this option.";
+                                        };
+                                    };
+                                    readonly required: readonly ["label", "value"];
+                                    readonly additionalProperties: false;
+                                };
+                            };
+                            readonly value: {
+                                readonly $ref: "common_types.json#/$defs/DynamicStringList";
+                                readonly description: "The list of currently selected values. This should be bound to a string array in the data model.";
+                            };
+                            readonly displayStyle: {
+                                readonly type: "string";
+                                readonly description: "The display style of the component.";
+                                readonly enum: readonly ["checkbox", "chips"];
+                                readonly default: "checkbox";
+                            };
+                            readonly filterable: {
+                                readonly type: "boolean";
+                                readonly description: "If true, displays a search input to filter the options.";
+                                readonly default: false;
+                            };
+                        };
+                        readonly required: readonly ["component", "options", "value"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly Slider: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly $ref: "common_types.json#/$defs/Checkable";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "Slider";
+                            };
+                            readonly label: {
+                                readonly $ref: "common_types.json#/$defs/DynamicString";
+                                readonly description: "The label for the slider.";
+                            };
+                            readonly min: {
+                                readonly type: "number";
+                                readonly description: "The minimum value of the slider.";
+                                readonly default: 0;
+                            };
+                            readonly max: {
+                                readonly type: "number";
+                                readonly description: "The maximum value of the slider.";
+                            };
+                            readonly value: {
+                                readonly $ref: "common_types.json#/$defs/DynamicNumber";
+                                readonly description: "The current value of the slider.";
+                            };
+                        };
+                        readonly required: readonly ["component", "value", "max"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly DateTimeInput: {
+                    readonly type: "object";
+                    readonly allOf: readonly [{
+                        readonly $ref: "common_types.json#/$defs/ComponentCommon";
+                    }, {
+                        readonly $ref: "#/$defs/CatalogComponentCommon";
+                    }, {
+                        readonly $ref: "common_types.json#/$defs/Checkable";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly component: {
+                                readonly const: "DateTimeInput";
+                            };
+                            readonly value: {
+                                readonly $ref: "common_types.json#/$defs/DynamicString";
+                                readonly description: "The selected date and/or time value in ISO 8601 format. If not yet set, initialize with an empty string.";
+                            };
+                            readonly enableDate: {
+                                readonly type: "boolean";
+                                readonly description: "If true, allows the user to select a date.";
+                                readonly default: false;
+                            };
+                            readonly enableTime: {
+                                readonly type: "boolean";
+                                readonly description: "If true, allows the user to select a time.";
+                                readonly default: false;
+                            };
+                            readonly min: {
+                                readonly allOf: readonly [{
+                                    readonly $ref: "common_types.json#/$defs/DynamicString";
+                                }, {
+                                    readonly if: {
+                                        readonly type: "string";
+                                    };
+                                    readonly then: {
+                                        readonly oneOf: readonly [{
+                                            readonly format: "date";
+                                        }, {
+                                            readonly format: "time";
+                                        }, {
+                                            readonly format: "date-time";
+                                        }];
+                                    };
+                                }];
+                                readonly description: "The minimum allowed date/time in ISO 8601 format.";
+                            };
+                            readonly max: {
+                                readonly allOf: readonly [{
+                                    readonly $ref: "common_types.json#/$defs/DynamicString";
+                                }, {
+                                    readonly if: {
+                                        readonly type: "string";
+                                    };
+                                    readonly then: {
+                                        readonly oneOf: readonly [{
+                                            readonly format: "date";
+                                        }, {
+                                            readonly format: "time";
+                                        }, {
+                                            readonly format: "date-time";
+                                        }];
+                                    };
+                                }];
+                                readonly description: "The maximum allowed date/time in ISO 8601 format.";
+                            };
+                            readonly label: {
+                                readonly $ref: "common_types.json#/$defs/DynamicString";
+                                readonly description: "The text label for the input field.";
+                            };
+                        };
+                        readonly required: readonly ["component", "value"];
+                    }];
+                    readonly unevaluatedProperties: false;
+                };
+            };
+            readonly functions: {
+                readonly required: {
+                    readonly type: "object";
+                    readonly description: "Checks that the value is not null, undefined, or empty.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly const: "required";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly value: {
+                                    readonly description: "The value to check.";
+                                };
+                            };
+                            readonly required: readonly ["value"];
+                            readonly additionalProperties: false;
+                        };
+                        readonly returnType: {
+                            readonly const: "boolean";
+                        };
+                    };
+                    readonly required: readonly ["call", "args"];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly regex: {
+                    readonly type: "object";
+                    readonly description: "Checks that the value matches a regular expression string.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly const: "regex";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly value: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicString";
+                                };
+                                readonly pattern: {
+                                    readonly type: "string";
+                                    readonly description: "The regex pattern to match against.";
+                                };
+                            };
+                            readonly required: readonly ["value", "pattern"];
+                            readonly unevaluatedProperties: false;
+                        };
+                        readonly returnType: {
+                            readonly const: "boolean";
+                        };
+                    };
+                    readonly required: readonly ["call", "args"];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly length: {
+                    readonly type: "object";
+                    readonly description: "Checks string length constraints.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly const: "length";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly value: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicString";
+                                };
+                                readonly min: {
+                                    readonly type: "integer";
+                                    readonly minimum: 0;
+                                    readonly description: "The minimum allowed length.";
+                                };
+                                readonly max: {
+                                    readonly type: "integer";
+                                    readonly minimum: 0;
+                                    readonly description: "The maximum allowed length.";
+                                };
+                            };
+                            readonly required: readonly ["value"];
+                            readonly anyOf: readonly [{
+                                readonly required: readonly ["min"];
+                            }, {
+                                readonly required: readonly ["max"];
+                            }];
+                            readonly unevaluatedProperties: false;
+                        };
+                        readonly returnType: {
+                            readonly const: "boolean";
+                        };
+                    };
+                    readonly required: readonly ["call", "args"];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly numeric: {
+                    readonly type: "object";
+                    readonly description: "Checks numeric range constraints.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly const: "numeric";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly value: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicNumber";
+                                };
+                                readonly min: {
+                                    readonly type: "number";
+                                    readonly description: "The minimum allowed value.";
+                                };
+                                readonly max: {
+                                    readonly type: "number";
+                                    readonly description: "The maximum allowed value.";
+                                };
+                            };
+                            readonly required: readonly ["value"];
+                            readonly anyOf: readonly [{
+                                readonly required: readonly ["min"];
+                            }, {
+                                readonly required: readonly ["max"];
+                            }];
+                            readonly unevaluatedProperties: false;
+                        };
+                        readonly returnType: {
+                            readonly const: "boolean";
+                        };
+                    };
+                    readonly required: readonly ["call", "args"];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly email: {
+                    readonly type: "object";
+                    readonly description: "Checks that the value is a valid email address.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly const: "email";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly value: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicString";
+                                };
+                            };
+                            readonly required: readonly ["value"];
+                            readonly unevaluatedProperties: false;
+                        };
+                        readonly returnType: {
+                            readonly const: "boolean";
+                        };
+                    };
+                    readonly required: readonly ["call", "args"];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly formatString: {
+                    readonly type: "object";
+                    readonly 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 `\\${`.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly const: "formatString";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly value: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicString";
+                                };
+                            };
+                            readonly required: readonly ["value"];
+                            readonly unevaluatedProperties: false;
+                        };
+                        readonly returnType: {
+                            readonly const: "string";
+                        };
+                    };
+                    readonly required: readonly ["call", "args"];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly formatNumber: {
+                    readonly type: "object";
+                    readonly description: "Formats a number with the specified grouping and decimal precision.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly const: "formatNumber";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly value: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicNumber";
+                                    readonly description: "The number to format.";
+                                };
+                                readonly decimals: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicNumber";
+                                    readonly description: "Optional. The number of decimal places to show. Defaults to 0 or 2 depending on locale.";
+                                };
+                                readonly grouping: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicBoolean";
+                                    readonly description: "Optional. If true, uses locale-specific grouping separators (e.g. '1,000'). If false, returns raw digits (e.g. '1000'). Defaults to true.";
+                                };
+                            };
+                            readonly required: readonly ["value"];
+                            readonly unevaluatedProperties: false;
+                        };
+                        readonly returnType: {
+                            readonly const: "string";
+                        };
+                    };
+                    readonly required: readonly ["call", "args"];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly formatCurrency: {
+                    readonly type: "object";
+                    readonly description: "Formats a number as a currency string.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly const: "formatCurrency";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly value: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicNumber";
+                                    readonly description: "The monetary amount.";
+                                };
+                                readonly currency: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicString";
+                                    readonly description: "The ISO 4217 currency code (e.g., 'USD', 'EUR').";
+                                };
+                                readonly decimals: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicNumber";
+                                    readonly description: "Optional. The number of decimal places to show. Defaults to 0 or 2 depending on locale.";
+                                };
+                                readonly grouping: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicBoolean";
+                                    readonly description: "Optional. If true, uses locale-specific grouping separators (e.g. '1,000'). If false, returns raw digits (e.g. '1000'). Defaults to true.";
+                                };
+                            };
+                            readonly required: readonly ["currency", "value"];
+                            readonly unevaluatedProperties: false;
+                        };
+                        readonly returnType: {
+                            readonly const: "string";
+                        };
+                    };
+                    readonly required: readonly ["call", "args"];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly formatDate: {
+                    readonly type: "object";
+                    readonly description: "Formats a timestamp into a string using a pattern.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly const: "formatDate";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly value: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicValue";
+                                    readonly description: "The date to format.";
+                                };
+                                readonly format: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicString";
+                                    readonly 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'";
+                                };
+                            };
+                            readonly required: readonly ["format", "value"];
+                            readonly unevaluatedProperties: false;
+                        };
+                        readonly returnType: {
+                            readonly const: "string";
+                        };
+                    };
+                    readonly required: readonly ["call", "args"];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly pluralize: {
+                    readonly type: "object";
+                    readonly 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'.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly const: "pluralize";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly value: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicNumber";
+                                    readonly description: "The numeric value used to determine the plural category.";
+                                };
+                                readonly zero: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicString";
+                                    readonly description: "String for the 'zero' category (e.g., 0 items).";
+                                };
+                                readonly one: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicString";
+                                    readonly description: "String for the 'one' category (e.g., 1 item).";
+                                };
+                                readonly two: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicString";
+                                    readonly description: "String for the 'two' category (used in Arabic, Welsh, etc.).";
+                                };
+                                readonly few: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicString";
+                                    readonly description: "String for the 'few' category (e.g., small groups in Slavic languages).";
+                                };
+                                readonly many: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicString";
+                                    readonly description: "String for the 'many' category (e.g., large groups in various languages).";
+                                };
+                                readonly other: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicString";
+                                    readonly description: "The default/fallback string (used for general plural cases).";
+                                };
+                            };
+                            readonly required: readonly ["value", "other"];
+                            readonly unevaluatedProperties: false;
+                        };
+                        readonly returnType: {
+                            readonly const: "string";
+                        };
+                    };
+                    readonly required: readonly ["call", "args"];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly openUrl: {
+                    readonly type: "object";
+                    readonly description: "Opens the specified URL in a browser or handler. This function has no return value.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly const: "openUrl";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly url: {
+                                    readonly type: "string";
+                                    readonly format: "uri";
+                                    readonly description: "The URL to open.";
+                                };
+                            };
+                            readonly required: readonly ["url"];
+                            readonly additionalProperties: false;
+                        };
+                        readonly returnType: {
+                            readonly const: "void";
+                        };
+                    };
+                    readonly required: readonly ["call", "args"];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly and: {
+                    readonly type: "object";
+                    readonly description: "Performs a logical AND operation on a list of boolean values.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly const: "and";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly values: {
+                                    readonly type: "array";
+                                    readonly description: "The list of boolean values to evaluate.";
+                                    readonly items: {
+                                        readonly $ref: "common_types.json#/$defs/DynamicBoolean";
+                                    };
+                                    readonly minItems: 2;
+                                };
+                            };
+                            readonly required: readonly ["values"];
+                            readonly unevaluatedProperties: false;
+                        };
+                        readonly returnType: {
+                            readonly const: "boolean";
+                        };
+                    };
+                    readonly required: readonly ["call", "args"];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly or: {
+                    readonly type: "object";
+                    readonly description: "Performs a logical OR operation on a list of boolean values.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly const: "or";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly values: {
+                                    readonly type: "array";
+                                    readonly description: "The list of boolean values to evaluate.";
+                                    readonly items: {
+                                        readonly $ref: "common_types.json#/$defs/DynamicBoolean";
+                                    };
+                                    readonly minItems: 2;
+                                };
+                            };
+                            readonly required: readonly ["values"];
+                            readonly unevaluatedProperties: false;
+                        };
+                        readonly returnType: {
+                            readonly const: "boolean";
+                        };
+                    };
+                    readonly required: readonly ["call", "args"];
+                    readonly unevaluatedProperties: false;
+                };
+                readonly not: {
+                    readonly type: "object";
+                    readonly description: "Performs a logical NOT operation on a boolean value.";
+                    readonly properties: {
+                        readonly call: {
+                            readonly const: "not";
+                        };
+                        readonly args: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly value: {
+                                    readonly $ref: "common_types.json#/$defs/DynamicBoolean";
+                                    readonly description: "The boolean value to negate.";
+                                };
+                            };
+                            readonly required: readonly ["value"];
+                            readonly unevaluatedProperties: false;
+                        };
+                        readonly returnType: {
+                            readonly const: "boolean";
+                        };
+                    };
+                    readonly required: readonly ["call", "args"];
+                    readonly unevaluatedProperties: false;
+                };
+            };
+            readonly $defs: {
+                readonly CatalogComponentCommon: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly weight: {
+                            readonly type: "number";
+                            readonly 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.";
+                        };
+                    };
+                };
+                readonly theme: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly primaryColor: {
+                            readonly type: "string";
+                            readonly 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').";
+                            readonly pattern: "^#[0-9a-fA-F]{6}$";
+                        };
+                        readonly iconUrl: {
+                            readonly type: "string";
+                            readonly format: "uri";
+                            readonly description: "A URL for an image that identifies the agent or tool associated with the surface.";
+                        };
+                        readonly agentDisplayName: {
+                            readonly type: "string";
+                            readonly description: "Text to be displayed next to the surface to identify the agent or tool that created it.";
+                        };
+                    };
+                    readonly additionalProperties: true;
+                };
+                readonly anyComponent: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/components/Text";
+                    }, {
+                        readonly $ref: "#/components/Image";
+                    }, {
+                        readonly $ref: "#/components/Icon";
+                    }, {
+                        readonly $ref: "#/components/Video";
+                    }, {
+                        readonly $ref: "#/components/AudioPlayer";
+                    }, {
+                        readonly $ref: "#/components/Row";
+                    }, {
+                        readonly $ref: "#/components/Column";
+                    }, {
+                        readonly $ref: "#/components/List";
+                    }, {
+                        readonly $ref: "#/components/Card";
+                    }, {
+                        readonly $ref: "#/components/Tabs";
+                    }, {
+                        readonly $ref: "#/components/Modal";
+                    }, {
+                        readonly $ref: "#/components/Divider";
+                    }, {
+                        readonly $ref: "#/components/Button";
+                    }, {
+                        readonly $ref: "#/components/TextField";
+                    }, {
+                        readonly $ref: "#/components/CheckBox";
+                    }, {
+                        readonly $ref: "#/components/ChoicePicker";
+                    }, {
+                        readonly $ref: "#/components/Slider";
+                    }, {
+                        readonly $ref: "#/components/DateTimeInput";
+                    }];
+                    readonly discriminator: {
+                        readonly propertyName: "component";
+                    };
+                };
+                readonly anyFunction: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/functions/required";
+                    }, {
+                        readonly $ref: "#/functions/regex";
+                    }, {
+                        readonly $ref: "#/functions/length";
+                    }, {
+                        readonly $ref: "#/functions/numeric";
+                    }, {
+                        readonly $ref: "#/functions/email";
+                    }, {
+                        readonly $ref: "#/functions/formatString";
+                    }, {
+                        readonly $ref: "#/functions/formatNumber";
+                    }, {
+                        readonly $ref: "#/functions/formatCurrency";
+                    }, {
+                        readonly $ref: "#/functions/formatDate";
+                    }, {
+                        readonly $ref: "#/functions/pluralize";
+                    }, {
+                        readonly $ref: "#/functions/openUrl";
+                    }, {
+                        readonly $ref: "#/functions/and";
+                    }, {
+                        readonly $ref: "#/functions/or";
+                    }, {
+                        readonly $ref: "#/functions/not";
+                    }];
+                };
+            };
+        };
+        readonly client_capabilities: {
+            readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+            readonly $id: "https://a2ui.org/specification/v0_9/client_capabilities.json";
+            readonly title: "A2UI Client Capabilities Schema";
+            readonly description: "A schema for the a2uiClientCapabilities object, which is sent from the client to the server as part of the A2A metadata to describe the client's UI rendering capabilities.";
+            readonly type: "object";
+            readonly properties: {
+                readonly "v0.9": {
+                    readonly type: "object";
+                    readonly description: "The capabilities structure for version 0.9 of the A2UI protocol.";
+                    readonly properties: {
+                        readonly supportedCatalogIds: {
+                            readonly type: "array";
+                            readonly description: "The URI of each of the component and function catalogs that is supported by the client.";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly inlineCatalogs: {
+                            readonly type: "array";
+                            readonly description: "An array of inline catalog definitions, which can contain both components and functions. This should only be provided if the agent declares 'acceptsInlineCatalogs: true' in its capabilities.";
+                            readonly items: {
+                                readonly $ref: "#/$defs/Catalog";
+                            };
+                        };
+                    };
+                    readonly required: readonly ["supportedCatalogIds"];
+                };
+            };
+            readonly required: readonly ["v0.9"];
+            readonly $defs: {
+                readonly FunctionDefinition: {
+                    readonly type: "object";
+                    readonly description: "Describes a function's interface.";
+                    readonly properties: {
+                        readonly name: {
+                            readonly type: "string";
+                            readonly description: "The unique name of the function.";
+                        };
+                        readonly description: {
+                            readonly type: "string";
+                            readonly description: "A human-readable description of what the function does and how to use it.";
+                        };
+                        readonly parameters: {
+                            readonly type: "object";
+                            readonly description: "A JSON Schema describing the expected arguments (args) for this function.";
+                            readonly $ref: "https://json-schema.org/draft/2020-12/schema";
+                        };
+                        readonly returnType: {
+                            readonly type: "string";
+                            readonly enum: readonly ["string", "number", "boolean", "array", "object", "any", "void"];
+                            readonly description: "The type of value this function returns.";
+                        };
+                    };
+                    readonly required: readonly ["name", "parameters", "returnType"];
+                    readonly additionalProperties: false;
+                };
+                readonly Catalog: {
+                    readonly type: "object";
+                    readonly description: "A collection of component and function definitions.";
+                    readonly properties: {
+                        readonly catalogId: {
+                            readonly type: "string";
+                            readonly description: "Unique identifier for this catalog.";
+                        };
+                        readonly components: {
+                            readonly type: "object";
+                            readonly description: "Definitions for UI components supported by this catalog.";
+                            readonly additionalProperties: {
+                                readonly $ref: "https://json-schema.org/draft/2020-12/schema";
+                            };
+                        };
+                        readonly functions: {
+                            readonly type: "array";
+                            readonly description: "Definitions for functions supported by this catalog.";
+                            readonly items: {
+                                readonly $ref: "#/$defs/FunctionDefinition";
+                            };
+                        };
+                        readonly theme: {
+                            readonly title: "A2UI Theme";
+                            readonly description: "A schema that defines a catalog of A2UI theme properties. Each key is a theme property name (e.g. 'primaryColor'), and each value is the JSON schema for that property.";
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly $ref: "https://json-schema.org/draft/2020-12/schema";
+                            };
+                        };
+                    };
+                    readonly required: readonly ["catalogId"];
+                    readonly additionalProperties: false;
+                };
+            };
+        };
+        readonly server_capabilities: {
+            readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+            readonly $id: "https://a2ui.org/specification/v0_9/server_capabilities.json";
+            readonly title: "A2UI Server Capabilities Schema";
+            readonly description: "A schema for the server capabilities object, which is used by an A2UI server (or Agent) to advertise its supported UI features to clients. This can be embedded in an Agent Card for A2A or used in other transport protocols like MCP.";
+            readonly type: "object";
+            readonly properties: {
+                readonly "v0.9": {
+                    readonly type: "object";
+                    readonly description: "The server capabilities structure for version 0.9 of the A2UI protocol.";
+                    readonly properties: {
+                        readonly supportedCatalogIds: {
+                            readonly type: "array";
+                            readonly description: "An array of strings, where each string is an ID identifying a Catalog Definition Schema that the server can generate. This is not necessarily a resolvable URI.";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly acceptsInlineCatalogs: {
+                            readonly type: "boolean";
+                            readonly description: "A boolean indicating if the server can accept an 'inlineCatalogs' array in the client's a2uiClientCapabilities. If omitted, this defaults to false.";
+                            readonly default: false;
+                        };
+                    };
+                };
+            };
+            readonly required: readonly ["v0.9"];
+        };
+        readonly client_data_model: {
+            readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+            readonly $id: "https://a2ui.org/specification/v0_9/client_data_model.json";
+            readonly title: "A2UI Client Data Model Schema";
+            readonly description: "Schema for attaching the client data model to A2A message metadata. This object should be placed in the `a2uiClientDataModel` field of the metadata.";
+            readonly type: "object";
+            readonly properties: {
+                readonly version: {
+                    readonly const: "v0.9";
+                };
+                readonly surfaces: {
+                    readonly type: "object";
+                    readonly description: "A map of surface IDs to their current data models.";
+                    readonly additionalProperties: {
+                        readonly type: "object";
+                        readonly description: "The current data model for the surface, as a standard JSON object.";
+                    };
+                };
+            };
+            readonly required: readonly ["version", "surfaces"];
+            readonly additionalProperties: false;
+        };
+    };
+};