1#![allow(dead_code)]
5
6use serde::{Deserialize, Serialize};
7
8#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
9#[serde(rename_all = "camelCase")]
10pub struct EngineWorkspaceV1Json {
11 pub root: String,
12 pub classname_transform: ClassnameTransformModeJson,
13 pub settings_key: String,
14}
15
16#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
17pub enum ClassnameTransformModeJson {
18 #[serde(rename = "asIs")]
19 AsIs,
20 #[serde(rename = "camelCase")]
21 CamelCase,
22 #[serde(rename = "camelCaseOnly")]
23 CamelCaseOnly,
24 #[serde(rename = "dashes")]
25 Dashes,
26 #[serde(rename = "dashesOnly")]
27 DashesOnly,
28}
29
30#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
31#[serde(rename_all = "camelCase")]
32pub struct SourceAnalysisInputV2Json {
33 pub file_path: String,
34 pub document: serde_json::Value,
35 #[serde(skip_serializing_if = "Option::is_none")]
36 pub binding_graph: Option<serde_json::Value>,
37}
38
39#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
40#[serde(rename_all = "camelCase")]
41pub struct StyleAnalysisInputV2Json {
42 pub file_path: String,
43 #[serde(skip_serializing_if = "Option::is_none")]
44 pub source: Option<String>,
45 pub document: serde_json::Value,
46}
47
48#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
49pub enum StringTypeFactKindV2Json {
50 #[serde(rename = "unknown")]
51 Unknown,
52 #[serde(rename = "exact")]
53 Exact,
54 #[serde(rename = "finiteSet")]
55 FiniteSet,
56 #[serde(rename = "constrained")]
57 Constrained,
58 #[serde(rename = "top")]
59 Top,
60}
61
62#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
63pub enum StringConstraintKindV2Json {
64 #[serde(rename = "prefix")]
65 Prefix,
66 #[serde(rename = "suffix")]
67 Suffix,
68 #[serde(rename = "prefixSuffix")]
69 PrefixSuffix,
70 #[serde(rename = "charInclusion")]
71 CharInclusion,
72 #[serde(rename = "composite")]
73 Composite,
74}
75
76pub type Utf16CodeUnitLengthV2Json = usize;
78
79pub type Utf16CodeUnitLengthOutputV2Json = i32;
82
83#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
84#[serde(rename_all = "camelCase")]
85pub struct StringTypeFactsV2Json {
86 pub kind: String,
87 #[serde(skip_serializing_if = "Option::is_none")]
88 pub values: Option<Vec<String>>,
89 #[serde(skip_serializing_if = "Option::is_none")]
90 pub constraint_kind: Option<String>,
91 #[serde(skip_serializing_if = "Option::is_none")]
92 pub prefix: Option<String>,
93 #[serde(skip_serializing_if = "Option::is_none")]
94 pub suffix: Option<String>,
95 #[serde(skip_serializing_if = "Option::is_none")]
96 pub min_len: Option<Utf16CodeUnitLengthV2Json>,
97 #[serde(skip_serializing_if = "Option::is_none")]
98 pub max_len: Option<Utf16CodeUnitLengthV2Json>,
99 #[serde(skip_serializing_if = "Option::is_none")]
100 pub char_must: Option<String>,
101 #[serde(skip_serializing_if = "Option::is_none")]
102 pub char_may: Option<String>,
103 #[serde(skip_serializing_if = "Option::is_none")]
104 pub may_include_other_chars: Option<bool>,
105 #[serde(skip_serializing_if = "Option::is_none")]
106 pub provenance: Option<String>,
107}
108
109#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
110#[serde(rename_all = "camelCase")]
111pub struct TypeFactControlFlowBlockV2Json {
112 pub id: String,
113 pub kind: String,
114 pub transfer_kind: String,
115 pub successor_block_ids: Vec<String>,
116 #[serde(skip_serializing_if = "Option::is_none")]
117 pub symbol_ordinal: Option<usize>,
118 #[serde(skip_serializing_if = "Option::is_none")]
119 pub variable_name: Option<String>,
120 #[serde(skip_serializing_if = "Option::is_none")]
121 pub expression_kind: Option<String>,
122 pub boundary_effect: String,
123 #[serde(skip_serializing_if = "Option::is_none")]
124 pub facts: Option<StringTypeFactsV2Json>,
125}
126
127#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
128#[serde(rename_all = "camelCase")]
129pub struct TypeFactControlFlowGraphV2Json {
130 pub entry_block_id: String,
131 pub blocks: Vec<TypeFactControlFlowBlockV2Json>,
132}
133
134#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
135#[serde(rename_all = "camelCase")]
136pub struct TypeFactEntryV2Json {
137 pub file_path: String,
138 pub expression_id: String,
139 pub facts: StringTypeFactsV2Json,
140 #[serde(skip_serializing_if = "Option::is_none")]
141 pub control_flow_graph: Option<TypeFactControlFlowGraphV2Json>,
142}
143
144#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
145#[serde(rename_all = "camelCase")]
146pub struct EngineInputV2Json {
147 pub version: String,
148 pub workspace: EngineWorkspaceV1Json,
149 pub sources: Vec<SourceAnalysisInputV2Json>,
150 pub styles: Vec<StyleAnalysisInputV2Json>,
151 pub type_facts: Vec<TypeFactEntryV2Json>,
152}
153
154#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
155pub enum ValueDomainKindV2Json {
156 #[serde(rename = "none")]
157 None,
158 #[serde(rename = "exact")]
159 Exact,
160 #[serde(rename = "finiteSet")]
161 FiniteSet,
162 #[serde(rename = "constrained")]
163 Constrained,
164 #[serde(rename = "top")]
165 Top,
166}
167
168#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
169pub enum CertaintyShapeKindV2Json {
170 #[serde(rename = "exact")]
171 Exact,
172 #[serde(rename = "boundedFinite")]
173 BoundedFinite,
174 #[serde(rename = "constrained")]
175 Constrained,
176 #[serde(rename = "unknown")]
177 Unknown,
178}
179
180#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
181#[serde(rename_all = "camelCase")]
182pub struct ValueDomainDerivationStepV2Json {
183 pub operation: String,
184 #[serde(skip_serializing_if = "Option::is_none")]
185 pub input_kind: Option<String>,
186 #[serde(skip_serializing_if = "Option::is_none")]
187 pub refinement_kind: Option<String>,
188 pub result_kind: String,
189 #[serde(skip_serializing_if = "Option::is_none")]
190 pub result_provenance: Option<String>,
191 pub reason: String,
192}
193
194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
195#[serde(rename_all = "camelCase")]
196pub struct ValueDomainDerivationV2Json {
197 pub schema_version: String,
198 pub product: String,
199 pub input_fact_kind: String,
200 #[serde(skip_serializing_if = "Option::is_none")]
201 pub input_constraint_kind: Option<String>,
202 pub input_value_count: i32,
203 pub reduced_kind: String,
204 pub steps: Vec<ValueDomainDerivationStepV2Json>,
205}
206
207#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
208#[serde(rename_all = "camelCase")]
209pub struct ValueDomainProvenanceNodeV2Json {
210 pub operation: String,
211 pub result_kind: String,
212 #[serde(skip_serializing_if = "Option::is_none")]
213 pub result_provenance: Option<String>,
214 #[serde(skip_serializing_if = "Option::is_none")]
215 pub detail: Option<String>,
216 pub reason: String,
217 pub children: Vec<ValueDomainProvenanceNodeV2Json>,
218}
219
220#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
221#[serde(rename_all = "camelCase")]
222pub struct ValueDomainProvenanceTreeV2Json {
223 pub schema_version: String,
224 pub product: String,
225 pub value_kind: String,
226 pub value: serde_json::Value,
227 #[serde(skip_serializing_if = "Option::is_none")]
228 pub value_provenance: Option<String>,
229 pub root: ValueDomainProvenanceNodeV2Json,
230}
231
232#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
233#[serde(rename_all = "camelCase")]
234pub struct ExpressionSemanticsPayloadV2Json {
235 pub expression_id: String,
236 pub expression_kind: String,
237 pub style_file_path: Option<String>,
238 pub selector_names: Vec<String>,
239 pub candidate_names: Vec<String>,
240 pub finite_values: Option<Vec<String>>,
241 pub value_domain_kind: ValueDomainKindV2Json,
242 #[serde(skip_serializing_if = "Option::is_none")]
243 pub value_constraint_kind: Option<StringConstraintKindV2Json>,
244 #[serde(skip_serializing_if = "Option::is_none")]
245 pub value_prefix: Option<String>,
246 #[serde(skip_serializing_if = "Option::is_none")]
247 pub value_suffix: Option<String>,
248 #[serde(skip_serializing_if = "Option::is_none")]
249 pub value_min_len: Option<Utf16CodeUnitLengthOutputV2Json>,
250 #[serde(skip_serializing_if = "Option::is_none")]
251 pub value_max_len: Option<Utf16CodeUnitLengthOutputV2Json>,
252 #[serde(skip_serializing_if = "Option::is_none")]
253 pub value_char_must: Option<String>,
254 #[serde(skip_serializing_if = "Option::is_none")]
255 pub value_char_may: Option<String>,
256 #[serde(skip_serializing_if = "Option::is_none")]
257 pub value_may_include_other_chars: Option<bool>,
258 #[serde(skip_serializing_if = "Option::is_none")]
259 pub value_domain_reason: Option<String>,
260 #[serde(skip_serializing_if = "Option::is_none")]
261 pub value_domain_derivation: Option<ValueDomainDerivationV2Json>,
262 #[serde(skip_serializing_if = "Option::is_none")]
263 pub value_domain_provenance_tree: Option<ValueDomainProvenanceTreeV2Json>,
264 pub selector_certainty: String,
265 #[serde(skip_serializing_if = "Option::is_none")]
266 pub selector_certainty_shape_kind: Option<CertaintyShapeKindV2Json>,
267 #[serde(skip_serializing_if = "Option::is_none")]
268 pub selector_constraint_kind: Option<StringConstraintKindV2Json>,
269 #[serde(skip_serializing_if = "Option::is_none")]
270 pub selector_certainty_shape_label: Option<String>,
271 #[serde(skip_serializing_if = "Option::is_none")]
272 pub selector_certainty_reason: Option<String>,
273 #[serde(skip_serializing_if = "Option::is_none")]
274 pub value_certainty: Option<String>,
275 #[serde(skip_serializing_if = "Option::is_none")]
276 pub value_certainty_shape_kind: Option<CertaintyShapeKindV2Json>,
277 #[serde(skip_serializing_if = "Option::is_none")]
278 pub value_certainty_constraint_kind: Option<StringConstraintKindV2Json>,
279 #[serde(skip_serializing_if = "Option::is_none")]
280 pub value_certainty_shape_label: Option<String>,
281 #[serde(skip_serializing_if = "Option::is_none")]
282 pub value_certainty_reason: Option<String>,
283 #[serde(skip_serializing_if = "Option::is_none")]
284 pub reason: Option<String>,
285}
286
287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
288#[serde(rename_all = "camelCase")]
289pub struct SourceExpressionResolutionPayloadV2Json {
290 pub expression_id: String,
291 pub style_file_path: Option<String>,
292 pub selector_names: Vec<String>,
293 pub finite_values: Option<Vec<String>>,
294 pub selector_certainty: String,
295 #[serde(skip_serializing_if = "Option::is_none")]
296 pub selector_certainty_shape_kind: Option<CertaintyShapeKindV2Json>,
297 #[serde(skip_serializing_if = "Option::is_none")]
298 pub selector_constraint_kind: Option<StringConstraintKindV2Json>,
299 #[serde(skip_serializing_if = "Option::is_none")]
300 pub selector_certainty_shape_label: Option<String>,
301 #[serde(skip_serializing_if = "Option::is_none")]
302 pub selector_certainty_reason: Option<String>,
303 #[serde(skip_serializing_if = "Option::is_none")]
304 pub value_certainty: Option<String>,
305 #[serde(skip_serializing_if = "Option::is_none")]
306 pub value_certainty_shape_kind: Option<CertaintyShapeKindV2Json>,
307 #[serde(skip_serializing_if = "Option::is_none")]
308 pub value_certainty_constraint_kind: Option<StringConstraintKindV2Json>,
309 #[serde(skip_serializing_if = "Option::is_none")]
310 pub value_prefix: Option<String>,
311 #[serde(skip_serializing_if = "Option::is_none")]
312 pub value_suffix: Option<String>,
313 #[serde(skip_serializing_if = "Option::is_none")]
314 pub value_min_len: Option<Utf16CodeUnitLengthOutputV2Json>,
315 #[serde(skip_serializing_if = "Option::is_none")]
316 pub value_max_len: Option<Utf16CodeUnitLengthOutputV2Json>,
317 #[serde(skip_serializing_if = "Option::is_none")]
318 pub value_char_must: Option<String>,
319 #[serde(skip_serializing_if = "Option::is_none")]
320 pub value_char_may: Option<String>,
321 #[serde(skip_serializing_if = "Option::is_none")]
322 pub value_may_include_other_chars: Option<bool>,
323 #[serde(skip_serializing_if = "Option::is_none")]
324 pub value_certainty_shape_label: Option<String>,
325 #[serde(skip_serializing_if = "Option::is_none")]
326 pub value_certainty_reason: Option<String>,
327 #[serde(skip_serializing_if = "Option::is_none")]
328 pub reason: Option<String>,
329}
330
331#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
332#[serde(rename_all = "camelCase")]
333pub struct SelectorUsagePayloadV2Json {
334 pub canonical_name: String,
335 pub total_references: i32,
336 pub direct_reference_count: i32,
337 pub editable_direct_reference_count: i32,
338 pub exact_reference_count: i32,
339 pub inferred_or_better_reference_count: i32,
340 pub has_expanded_references: bool,
341 pub has_style_dependency_references: bool,
342 pub has_any_references: bool,
343}
344
345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
346#[serde(
347 tag = "kind",
348 rename_all = "kebab-case",
349 rename_all_fields = "camelCase"
350)]
351#[allow(clippy::large_enum_variant)]
352pub enum QueryResultV2Json {
353 #[serde(rename = "expression-semantics")]
354 ExpressionSemantics {
355 file_path: String,
356 query_id: String,
357 payload: ExpressionSemanticsPayloadV2Json,
358 },
359 #[serde(rename = "source-expression-resolution")]
360 SourceExpressionResolution {
361 file_path: String,
362 query_id: String,
363 payload: SourceExpressionResolutionPayloadV2Json,
364 },
365 #[serde(rename = "selector-usage")]
366 SelectorUsage {
367 file_path: String,
368 query_id: String,
369 payload: SelectorUsagePayloadV2Json,
370 },
371}
372
373#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
374#[serde(rename_all = "camelCase")]
375pub struct TextPositionJsonV2Json {
376 pub line: i32,
377 pub character: i32,
378}
379
380#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
381#[serde(rename_all = "camelCase")]
382pub struct TextRangeJsonV2Json {
383 pub start: TextPositionJsonV2Json,
384 pub end: TextPositionJsonV2Json,
385}
386
387#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
388#[serde(rename_all = "camelCase")]
389pub struct PlannedTextEditJsonV2Json {
390 pub uri: String,
391 pub range: TextRangeJsonV2Json,
392 pub new_text: String,
393}
394
395#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
396#[serde(rename_all = "camelCase")]
397pub struct TextRewritePlanJsonV2Json {
398 pub target: serde_json::Value,
399 pub edits: Vec<PlannedTextEditJsonV2Json>,
400}
401
402#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
403#[serde(rename_all = "camelCase")]
404pub struct CheckerReportJsonV1Json {
405 pub version: String,
406 pub findings: Vec<serde_json::Value>,
407 pub summary: serde_json::Value,
408}
409
410#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
411#[serde(rename_all = "camelCase")]
412pub struct EngineOutputV2Json {
413 pub version: String,
414 pub query_results: Vec<QueryResultV2Json>,
415 pub rewrite_plans: Vec<TextRewritePlanJsonV2Json>,
416 pub checker_report: CheckerReportJsonV1Json,
417}
418
419#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
420pub enum CodeActionPlanKindJson {
421 #[serde(rename = "quickfix")]
422 Quickfix,
423 #[serde(rename = "refactor.extract")]
424 RefactorExtract,
425 #[serde(rename = "refactor.inline")]
426 RefactorInline,
427}
428
429#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
430#[serde(rename_all = "camelCase")]
431pub struct OmenaQueryWorkspaceTextEditV0Json {
432 pub uri: String,
433 pub range: serde_json::Value,
434 pub new_text: String,
435}
436
437#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
438#[serde(rename_all = "camelCase")]
439pub struct OmenaQueryCodeActionV0Json {
440 pub title: String,
441 pub kind: CodeActionPlanKindJson,
442 pub edits: Vec<OmenaQueryWorkspaceTextEditV0Json>,
443 pub source: String,
444}
445
446#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
447#[serde(rename_all = "camelCase")]
448pub struct OmenaQueryCodeActionPlanV0Json {
449 pub schema_version: String,
450 pub product: String,
451 pub file_uri: String,
452 pub file_kind: String,
453 pub action_count: i32,
454 pub actions: Vec<OmenaQueryCodeActionV0Json>,
455 #[serde(skip_serializing_if = "Option::is_none")]
456 pub ready_surfaces: Option<Vec<String>>,
457}