1use serde::{Deserialize, Serialize};
6
7pub type ComponentId = String;
9
10#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
12pub struct DataBinding {
13 pub path: String,
15}
16
17#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
19#[serde(rename_all = "camelCase")]
20pub struct FunctionCall {
21 pub call: String,
23 #[serde(skip_serializing_if = "Option::is_none")]
25 pub args: Option<serde_json::Value>,
26 #[serde(skip_serializing_if = "Option::is_none")]
28 pub return_type: Option<ReturnType>,
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
33#[serde(rename_all = "lowercase")]
34pub enum ReturnType {
35 String,
36 Number,
37 Boolean,
38 Array,
39 Object,
40 Any,
41 Void,
42}
43
44#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
46#[serde(untagged)]
47pub enum DynamicValue {
48 String(String),
50 Number(f64),
52 Boolean(bool),
54 Array(Vec<serde_json::Value>),
56 Binding(DataBinding),
58 Function(FunctionCall),
60}
61
62#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
64#[serde(untagged)]
65pub enum DynamicString {
66 Literal(String),
67 Binding(DataBinding),
68 Function(FunctionCall),
69}
70
71impl From<&str> for DynamicString {
72 fn from(s: &str) -> Self {
73 DynamicString::Literal(s.to_string())
74 }
75}
76
77impl From<String> for DynamicString {
78 fn from(s: String) -> Self {
79 DynamicString::Literal(s)
80 }
81}
82
83#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
85#[serde(untagged)]
86pub enum DynamicNumber {
87 Literal(f64),
88 Binding(DataBinding),
89 Function(FunctionCall),
90}
91
92impl From<f64> for DynamicNumber {
93 fn from(n: f64) -> Self {
94 DynamicNumber::Literal(n)
95 }
96}
97
98impl From<i32> for DynamicNumber {
99 fn from(n: i32) -> Self {
100 DynamicNumber::Literal(n as f64)
101 }
102}
103
104#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
106#[serde(untagged)]
107pub enum DynamicBoolean {
108 Literal(bool),
109 Binding(DataBinding),
110 Function(FunctionCall),
111}
112
113impl From<bool> for DynamicBoolean {
114 fn from(b: bool) -> Self {
115 DynamicBoolean::Literal(b)
116 }
117}
118
119#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
121#[serde(untagged)]
122pub enum DynamicStringList {
123 Literal(Vec<String>),
124 Binding(DataBinding),
125 Function(FunctionCall),
126}
127
128#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
130#[serde(untagged)]
131pub enum ChildList {
132 Static(Vec<ComponentId>),
134 Template(ChildTemplate),
136}
137
138#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
140#[serde(rename_all = "camelCase")]
141pub struct ChildTemplate {
142 pub component_id: ComponentId,
144 pub path: String,
146}
147
148#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
150pub struct CheckRule {
151 pub condition: DynamicBoolean,
153 pub message: String,
155}
156
157#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
159pub struct Checkable {
160 #[serde(skip_serializing_if = "Option::is_none")]
162 pub checks: Option<Vec<CheckRule>>,
163}
164
165#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
167pub struct AccessibilityAttributes {
168 #[serde(skip_serializing_if = "Option::is_none")]
170 pub label: Option<DynamicString>,
171 #[serde(skip_serializing_if = "Option::is_none")]
173 pub description: Option<DynamicString>,
174}
175
176#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
178#[serde(untagged)]
179pub enum Action {
180 Event(EventAction),
182 Function(FunctionAction),
184}
185
186#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
188pub struct EventAction {
189 pub event: EventDefinition,
191}
192
193#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
195pub struct EventDefinition {
196 pub name: String,
198 #[serde(skip_serializing_if = "Option::is_none")]
200 pub context: Option<serde_json::Map<String, serde_json::Value>>,
201}
202
203#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
205#[serde(rename_all = "camelCase")]
206pub struct FunctionAction {
207 pub function_call: FunctionCall,
209}