1#![allow(dead_code)]
5
6use serde::{Deserialize, Serialize};
7use std::collections::BTreeMap;
8
9#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
10#[serde(rename_all = "camelCase")]
11pub enum OmenaSdkResponsePartitionV0 {
12 Public,
13 Debug,
14}
15
16#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
17#[serde(rename_all = "camelCase")]
18pub enum OmenaErrorClassV0 {
19 Input,
20 Workspace,
21 Resolution,
22 Analysis,
23 Transform,
24 Unsupported,
25 Internal,
26 Unknown,
27}
28
29#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
30#[serde(rename_all = "camelCase")]
31pub enum OmenaErrorSeverityV0 {
32 Error,
33 Warning,
34 Information,
35}
36
37#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
38pub enum OmenaErrorRecoverabilityV0 {
39 #[serde(rename = "retry")]
40 Retry,
41 #[serde(rename = "user-action")]
42 UserAction,
43 #[serde(rename = "not-recoverable")]
44 NotRecoverable,
45}
46
47#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
48#[serde(rename_all = "camelCase")]
49pub struct OmenaErrorEvidenceReferenceV0 {
50 pub query_identity: String,
51 pub input_identity: String,
52}
53
54#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
55#[serde(rename_all = "camelCase")]
56pub struct OmenaErrorContextV0 {
57 pub code: String,
58 pub severity: OmenaErrorSeverityV0,
59 pub recoverability: OmenaErrorRecoverabilityV0,
60 #[serde(default, skip_serializing_if = "Vec::is_empty")]
61 pub evidence: Vec<OmenaErrorEvidenceReferenceV0>,
62}
63
64#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
65#[serde(rename_all = "camelCase")]
66pub struct OmenaErrorV0 {
67 pub class: OmenaErrorClassV0,
68 pub message: String,
69 pub context: OmenaErrorContextV0,
70}
71
72#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
73#[serde(rename_all = "camelCase")]
74pub struct OmenaSdkErrorEnvelopeV0 {
75 pub error: OmenaErrorV0,
76}
77
78#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
79#[serde(rename_all = "camelCase")]
80pub struct OmenaCliResponseEnvelopeV0 {
81 pub schema_version: String,
82 pub product: String,
83 #[serde(skip_serializing_if = "Option::is_none")]
84 pub config_content_digest: Option<String>,
85 pub payload: serde_json::Value,
86}
87
88#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
89#[serde(rename_all = "camelCase")]
90pub struct OmenaSdkSnapshotRequestV0 {
91 pub workspace_root: String,
92}
93
94#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
95#[serde(rename_all = "camelCase")]
96pub struct OmenaSdkSnapshotResponseV0 {
97 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
98 pub partition: OmenaSdkResponsePartitionV0,
99 pub workspace_root: String,
100}
101
102#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
103#[serde(rename_all = "camelCase")]
104pub struct OmenaSdkQueryRequestV0 {
105 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
106 pub query_kind: String,
107 #[serde(skip_serializing_if = "Option::is_none")]
108 pub input: Option<serde_json::Value>,
109}
110
111#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
112#[serde(rename_all = "camelCase")]
113pub struct OmenaSdkQueryResponseV0 {
114 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
115 pub partition: OmenaSdkResponsePartitionV0,
116 pub payload: serde_json::Value,
117}
118
119#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
120#[serde(rename_all = "camelCase")]
121pub struct OmenaSdkDiagnosticsRequestV0 {
122 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
123 pub style_path: String,
124 pub style_source: String,
125}
126
127#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
128#[serde(rename_all = "camelCase")]
129pub struct OmenaSdkDiagnosticsSummaryV0 {
130 pub schema_version: String,
131 pub product: String,
132 pub style_path: String,
133 pub dialect: String,
134 pub token_count: u64,
135 pub parser_error_count: u64,
136 pub class_selector_count: u64,
137 pub custom_property_count: u64,
138 pub keyframe_count: u64,
139 pub ready_surfaces: Vec<String>,
140}
141
142#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
143#[serde(rename_all = "camelCase")]
144pub struct OmenaSdkDiagnosticsResponseV0 {
145 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
146 pub partition: OmenaSdkResponsePartitionV0,
147 pub summary: OmenaSdkDiagnosticsSummaryV0,
148}
149
150#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
151#[serde(rename_all = "camelCase")]
152pub struct OmenaSdkDiagnosticsDebugReportV0 {
153 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
154 pub partition: OmenaSdkResponsePartitionV0,
155 pub public_response: OmenaSdkDiagnosticsResponseV0,
156 pub analysis: serde_json::Value,
157}
158
159#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
160#[serde(rename_all = "camelCase")]
161pub enum OmenaSdkBuildVerificationProfileV0 {
162 Descriptive,
163 Strict,
164}
165
166#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
167#[serde(rename_all = "camelCase")]
168pub enum OmenaSdkBuildVerificationReasonV0 {
169 RequiredAxisUnavailable,
170 CascadeEnvironmentUnavailable,
171 WinnerChanged,
172 ObservationUnavailable,
173 UnknownPass,
174 ClosedWorldEvidenceUnavailable,
175 DecisionCoverageIncomplete,
176}
177
178#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
179#[serde(rename_all = "camelCase")]
180pub struct OmenaSdkBuildVerificationEventV0 {
181 pub pass_id: String,
182 pub reasons: Vec<OmenaSdkBuildVerificationReasonV0>,
183}
184
185#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
186#[serde(rename_all = "camelCase")]
187pub struct OmenaSdkBuildVerificationSummaryV0 {
188 #[serde(skip_serializing_if = "Option::is_none")]
189 pub profile_id: Option<String>,
190 pub refused_count: u64,
191 pub rolled_back_count: u64,
192 pub refusal_reasons: Vec<OmenaSdkBuildVerificationEventV0>,
193 pub rollback_reasons: Vec<OmenaSdkBuildVerificationEventV0>,
194}
195
196#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
197#[serde(rename_all = "camelCase")]
198pub struct OmenaSdkBuildRequestV0 {
199 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
200 pub style_path: String,
201 pub style_source: String,
202 pub pass_ids: Vec<String>,
203 #[serde(skip_serializing_if = "Option::is_none")]
204 pub verification_profile: Option<OmenaSdkBuildVerificationProfileV0>,
205 #[serde(skip_serializing_if = "Option::is_none")]
206 pub context: Option<crate::OmenaQueryTransformExecutionContextV0>,
207}
208
209#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
210#[serde(rename_all = "camelCase")]
211pub struct OmenaSdkBuildResponseV0 {
212 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
213 pub partition: OmenaSdkResponsePartitionV0,
214 pub verification: OmenaSdkBuildVerificationSummaryV0,
215 pub summary: serde_json::Value,
216}
217
218#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
219#[serde(rename_all = "camelCase")]
220pub struct OmenaSdkExplainPositionV0 {
221 pub line: i32,
222 pub character: i32,
223}
224
225#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
226#[serde(rename_all = "camelCase")]
227pub struct OmenaSdkExplainRequestV0 {
228 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
229 pub style_path: String,
230 pub position: OmenaSdkExplainPositionV0,
231}
232
233#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
234#[serde(rename_all = "camelCase")]
235pub struct OmenaSdkExplainResponseV0 {
236 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
237 pub partition: OmenaSdkResponsePartitionV0,
238 pub report: serde_json::Value,
239}
240
241#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
242#[serde(rename_all = "camelCase")]
243pub enum OmenaWorkspaceSessionOperationV0 {
244 Diagnostics,
245 Format,
246 Lint,
247 Check,
248 Explain,
249 ReplaceStyleSources,
250 Cancel,
251 Shutdown,
252}
253
254#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
255#[serde(rename_all = "camelCase")]
256pub struct OmenaWorkspaceSessionLimitsV0 {
257 pub deadline_ms: u64,
258 pub max_response_bytes: u64,
259}
260
261#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
262#[serde(rename_all = "camelCase")]
263pub struct OmenaWorkspaceSessionHandshakeRequestV0 {
264 pub protocol_version: String,
265 pub workspace_root: String,
266 #[serde(skip_serializing_if = "Option::is_none")]
267 pub config_content_digest: Option<String>,
268 pub style_sources: Vec<crate::OmenaQueryStyleSourceInputV0>,
269 pub limits: OmenaWorkspaceSessionLimitsV0,
270}
271
272#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
273#[serde(rename_all = "camelCase")]
274pub struct OmenaWorkspaceSessionHandshakeResponseV0 {
275 pub protocol_version: String,
276 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
277 pub partition: OmenaSdkResponsePartitionV0,
278 pub workspace_root: String,
279 #[serde(skip_serializing_if = "Option::is_none")]
280 pub config_content_digest: Option<String>,
281 pub capabilities: Vec<String>,
282}
283
284#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
285#[serde(rename_all = "camelCase")]
286pub struct OmenaWorkspaceSessionRequestV0 {
287 pub request_id: String,
288 pub protocol_version: String,
289 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
290 pub operation: OmenaWorkspaceSessionOperationV0,
291 pub limits: OmenaWorkspaceSessionLimitsV0,
292 #[serde(skip_serializing_if = "Option::is_none")]
293 pub payload: Option<serde_json::Value>,
294}
295
296#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
297#[serde(rename_all = "camelCase")]
298pub struct OmenaWorkspaceSessionResponseV0 {
299 pub request_id: String,
300 pub protocol_version: String,
301 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
302 pub partition: OmenaSdkResponsePartitionV0,
303 pub ok: bool,
304 #[serde(skip_serializing_if = "Option::is_none")]
305 pub payload: Option<serde_json::Value>,
306 #[serde(skip_serializing_if = "Option::is_none")]
307 pub error: Option<OmenaErrorV0>,
308}
309
310#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
311#[serde(rename_all = "camelCase")]
312pub struct OmenaBundlerHostCapabilitiesV0 {
313 pub protocol_version: String,
314 pub capabilities: Vec<String>,
315}
316
317#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
318#[serde(rename_all = "camelCase")]
319pub struct OmenaBundlerHostResolveModuleRequestV0 {
320 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
321 pub style_path: String,
322 pub style_sources: Vec<crate::OmenaQueryStyleSourceInputV0>,
323 pub package_manifests: Vec<crate::OmenaQueryStylePackageManifestV0>,
324}
325
326#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
327#[serde(rename_all = "camelCase")]
328pub struct OmenaBundlerHostComposesEdgeV0 {
329 pub exported_name: String,
330 pub module_id: String,
331 pub class_name: String,
332}
333
334#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
335#[serde(rename_all = "camelCase")]
336pub struct OmenaBundlerHostDiagnosticV0 {
337 pub code: String,
338 pub message: String,
339}
340
341#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
342#[serde(rename_all = "camelCase")]
343pub struct OmenaBundlerHostResolveModuleResponseV0 {
344 pub snapshot_id: crate::OmenaWorkspaceSnapshotIdV0,
345 pub protocol_version: String,
346 pub module_id: String,
347 pub class_map: BTreeMap<String, String>,
348 pub named_exports: BTreeMap<String, String>,
349 pub typescript_declaration: String,
350 pub composes_edges: Vec<OmenaBundlerHostComposesEdgeV0>,
351 pub diagnostics: Vec<OmenaBundlerHostDiagnosticV0>,
352 pub ready: bool,
353}