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