1use super::*;
2use omena_sif::OmenaSifV1;
3
4pub const OMENA_QUERY_CURRENT_SCHEMA_VERSION: &str = "0";
5pub const OMENA_QUERY_CURRENT_SCHEMA_VERSION_LABEL: &str = "V0";
6
7#[derive(Debug, Clone, PartialEq, Serialize)]
8#[serde(rename_all = "camelCase")]
9pub struct DesignSystemMinimumDescriptionV0 {
10 pub schema_version: &'static str,
11 pub product: &'static str,
12 pub layer_marker: &'static str,
13 pub feature_gate: &'static str,
14 pub model_bits: f64,
15 pub residual_bits: f64,
16 pub total_bits: f64,
17 pub unit: &'static str,
18 pub model_class: ModelClassV0,
19 pub rule_count: usize,
20 pub observation_count: usize,
21 pub canonical_form_present: bool,
22 pub cascade_proof_obligation_count: usize,
23 pub sass_namespace_partition: SassNamespaceBitsV0,
24 pub generated_at_iso: &'static str,
25 pub source_pin: SourcePinV0,
26 pub weights_calibration_pin: &'static str,
27 pub weights_version: &'static str,
28 pub semiring_instance: &'static str,
29}
30
31#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
32#[serde(rename_all = "camelCase")]
33pub enum ModelClassV0 {
34 TwoPartUniform,
35 TwoPartMultinomial,
36 Nml,
37}
38
39#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
40#[serde(rename_all = "camelCase")]
41pub struct SassNamespaceBitsV0 {
42 pub namespace_count: usize,
43 pub partition_count: usize,
44 pub deterministic_partition: bool,
45}
46
47#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
48#[serde(rename_all = "camelCase")]
49pub struct SourcePinV0 {
50 pub source_uri: String,
51 pub source_hash: String,
52}
53
54#[derive(Debug, Clone, PartialEq, Serialize)]
55#[serde(rename_all = "camelCase")]
56pub struct CanonicalFormV0 {
57 pub schema_version: &'static str,
58 pub product: &'static str,
59 pub layer_marker: &'static str,
60 pub feature_gate: &'static str,
61 pub pass_id: &'static str,
62 pub before: String,
63 pub canonical_after: String,
64 pub fallback_after: String,
65 pub canonical_matches_fallback: bool,
66 pub mdl_bits: f64,
67 pub ast_size_bits: f64,
68 pub bits_saved_vs_fallback: f64,
69 pub unit: &'static str,
70 pub iteration_count: usize,
71 pub eclass_count: usize,
72 pub enode_count: usize,
73 pub cascade_safe_witness: &'static str,
74 pub egg_analysis_witness: &'static str,
75}
76
77#[derive(Debug, Serialize)]
78#[serde(rename_all = "camelCase")]
79pub struct OmenaQueryBoundarySummaryV0 {
80 pub schema_version: &'static str,
81 pub product: &'static str,
82 pub query_engine_name: &'static str,
83 pub schema_version_policy: OmenaQuerySchemaVersionPolicyV0,
84 pub input_version: String,
85 pub abstract_value_domain: AbstractValueDomainSummaryV0,
86 pub selected_query_adapter_capabilities: SelectedQueryAdapterCapabilitiesV0,
87 pub delegated_fragment_products: Vec<&'static str>,
88 pub expression_semantics_query_count: usize,
89 pub source_resolution_query_count: usize,
90 pub selector_usage_query_count: usize,
91 pub total_query_count: usize,
92 pub ready_surfaces: Vec<&'static str>,
93 pub cme_coupled_surfaces: Vec<&'static str>,
94 pub next_decoupling_targets: Vec<&'static str>,
95}
96
97#[derive(Debug, Serialize)]
98#[serde(rename_all = "camelCase")]
99pub struct OmenaQueryEvaluationRuntimeSummaryV0 {
100 pub schema_version: &'static str,
101 pub product: &'static str,
102 pub input_version: String,
103 pub selected_query_adapter_capabilities: SelectedQueryAdapterCapabilitiesV0,
104 pub runtime_products: Vec<&'static str>,
105 pub source_resolution_expression_count: usize,
106 pub source_resolution_unresolved_expression_count: usize,
107 pub expression_domain_revision: u64,
108 pub expression_domain_graph_count: usize,
109 pub expression_domain_dirty_graph_count: usize,
110 pub expression_domain_reused_graph_count: usize,
111 pub style_document_summary_source: &'static str,
112 pub ready_surfaces: Vec<&'static str>,
113 pub retired_couplings: Vec<&'static str>,
114}
115
116#[derive(Debug, Serialize)]
117#[serde(rename_all = "camelCase")]
118pub struct OmenaQueryFragmentBundleV0 {
119 pub schema_version: &'static str,
120 pub product: &'static str,
121 pub input_version: String,
122 pub expression_semantics: ExpressionSemanticsQueryFragmentsV0,
123 pub source_resolution: SourceResolutionQueryFragmentsV0,
124 pub selector_usage: SelectorUsageQueryFragmentsV0,
125}
126
127#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
128#[serde(rename_all = "camelCase")]
129pub struct SelectedQueryAdapterCapabilitiesV0 {
130 pub schema_version: &'static str,
131 pub product: &'static str,
132 pub default_candidate_backend: &'static str,
133 pub schema_version_policy: OmenaQuerySchemaVersionPolicyV0,
134 pub schema_version_checks: Vec<OmenaQuerySchemaVersionCheckV0>,
135 pub backend_kinds: Vec<SelectedQueryBackendCapabilityV0>,
136 pub runner_commands: Vec<SelectedQueryRunnerCommandV0>,
137 pub expression_semantics_payload_contracts: Vec<&'static str>,
138 pub required_input_contracts: Vec<&'static str>,
139 pub adapter_readiness: Vec<&'static str>,
140 pub routing_status: &'static str,
141}
142
143#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
144#[serde(rename_all = "camelCase")]
145pub struct OmenaQuerySchemaVersionPolicyV0 {
146 pub schema_version: &'static str,
147 pub product: &'static str,
148 pub current_version: &'static str,
149 pub current_version_label: &'static str,
150 pub accepted_versions: Vec<&'static str>,
151 pub deprecated_versions: Vec<&'static str>,
152 pub rejected_version_policy: &'static str,
153 pub missing_version_policy: &'static str,
154 pub migration_policy: Vec<&'static str>,
155 pub compatibility_gate: &'static str,
156}
157
158#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
159#[serde(rename_all = "camelCase")]
160pub struct OmenaQuerySchemaVersionCheckV0 {
161 pub schema_version: &'static str,
162 pub product: &'static str,
163 pub requested_version: Option<String>,
164 pub current_version: &'static str,
165 pub accepted: bool,
166 pub status: &'static str,
167 pub migration_action: &'static str,
168 pub reason: &'static str,
169}
170
171#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
172#[serde(rename_all = "camelCase")]
173pub struct SelectedQueryBackendCapabilityV0 {
174 pub backend_kind: &'static str,
175 pub source_resolution: bool,
176 pub expression_semantics: bool,
177 pub selector_usage: bool,
178 pub style_semantic_graph: bool,
179}
180
181#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
182#[serde(rename_all = "camelCase")]
183pub struct SelectedQueryRunnerCommandV0 {
184 pub surface: &'static str,
185 pub command: &'static str,
186 pub input_contract: &'static str,
187 pub output_product: &'static str,
188}
189
190#[derive(Debug, Serialize)]
191#[serde(rename_all = "camelCase")]
192pub struct OmenaQueryStyleSemanticGraphBatchOutputV0 {
193 pub schema_version: &'static str,
194 pub product: &'static str,
195 pub cross_file_summary: OmenaQueryCrossFileSummaryV0,
196 pub css_modules_resolution: OmenaQueryCssModulesCrossFileResolutionV0,
197 pub sass_module_resolution: OmenaQuerySassModuleCrossFileResolutionV0,
198 pub graphs: Vec<OmenaQueryStyleSemanticGraphBatchEntryV0>,
199}
200
201#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
202#[serde(rename_all = "camelCase")]
203pub struct OmenaQueryCrossFileSummaryV0 {
204 pub schema_version: &'static str,
205 pub product: &'static str,
206 pub status: &'static str,
207 pub summary_scope: &'static str,
208 pub style_count: usize,
209 pub summary_edge_count: usize,
210 pub edge_kind_counts: Vec<OmenaQueryCrossFileSummaryEdgeKindCountV0>,
211 pub summary_hash: String,
212 pub edges: Vec<OmenaQueryCrossFileSummaryEdgeV0>,
213 pub capabilities: OmenaQueryCrossFileSummaryCapabilitiesV0,
214 pub next_priorities: Vec<&'static str>,
215}
216
217#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
218#[serde(rename_all = "camelCase")]
219pub struct OmenaQueryCrossFileSummaryEdgeKindCountV0 {
220 pub edge_kind: &'static str,
221 pub count: usize,
222}
223
224#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
225#[serde(rename_all = "camelCase")]
226pub struct OmenaQueryCrossFileSummaryEdgeV0 {
227 pub edge_id: String,
228 pub edge_kind: &'static str,
229 pub from_kind: &'static str,
230 pub from_path: String,
231 pub target_kind: Option<&'static str>,
232 pub target_path: Option<String>,
233 pub source: Option<String>,
234 pub owner_selector_name: Option<String>,
235 pub local_name: Option<String>,
236 pub remote_name: Option<String>,
237 pub target_names: Vec<String>,
238 pub status: &'static str,
239 pub provenance: Vec<&'static str>,
240 pub linear_provenance: OmenaQueryLinearProvenanceV0,
241}
242
243#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
244#[serde(rename_all = "camelCase")]
245pub struct OmenaQueryCrossFileSummaryCapabilitiesV0 {
246 pub css_modules_composes_edges_ready: bool,
247 pub css_modules_value_edges_ready: bool,
248 pub css_modules_icss_edges_ready: bool,
249 pub sass_module_edges_ready: bool,
250 pub style_design_token_reference_edges_ready: bool,
251 pub source_selector_reference_edges_ready: bool,
252 pub stable_summary_hash_ready: bool,
253 pub linear_provenance_ready: bool,
254 pub linear_provenance_round_trip_ready: bool,
255}
256
257#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
258#[serde(rename_all = "camelCase")]
259pub struct OmenaQueryM4AxisCReadinessSummaryV0 {
260 pub schema_version: &'static str,
261 pub product: &'static str,
262 pub status: &'static str,
263 pub required_edge_kind_count: usize,
264 pub required_edge_kind_counts: Vec<OmenaQueryCrossFileSummaryEdgeKindCountV0>,
265 pub workspace_edge_count: usize,
266 pub issue_63_provenance_round_trip_ready: bool,
267 pub issue_65_summary_edge_equivalence_ready: bool,
268 pub summary_hash_invalidation_ready: bool,
269 pub summary_hash_samples: OmenaQueryM4AxisCSummaryHashSamplesV0,
270 pub checked_surfaces: Vec<&'static str>,
271 pub next_priorities: Vec<&'static str>,
272}
273
274#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
275#[serde(rename_all = "camelCase")]
276pub struct OmenaQueryM4AxisCSummaryHashSamplesV0 {
277 pub baseline: String,
278 pub source_selector_change: String,
279 pub style_edge_change: String,
280 pub package_manifest_change: String,
281}
282
283#[derive(Debug, Serialize)]
284#[serde(rename_all = "camelCase")]
285pub struct OmenaQueryStyleSemanticGraphBatchEntryV0 {
286 pub style_path: String,
287 pub graph: Option<StyleSemanticGraphSummaryV0>,
288}
289
290#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
291#[serde(rename_all = "camelCase")]
292pub struct OmenaQueryCssModulesCrossFileResolutionV0 {
293 pub schema_version: &'static str,
294 pub product: &'static str,
295 pub status: &'static str,
296 pub resolution_scope: &'static str,
297 pub style_count: usize,
298 pub import_edge_count: usize,
299 pub resolved_import_edge_count: usize,
300 pub unresolved_import_edge_count: usize,
301 pub matched_name_count: usize,
302 pub edges: Vec<OmenaQueryCssModulesImportEdgeResolutionV0>,
303 pub composes_closure_edge_count: usize,
304 pub value_closure_edge_count: usize,
305 pub icss_closure_edge_count: usize,
306 pub composes_cycle_count: usize,
307 pub value_cycle_count: usize,
308 pub icss_cycle_count: usize,
309 pub composes_closure_edges: Vec<OmenaQueryCssModulesComposesClosureEdgeV0>,
310 pub value_closure_edges: Vec<OmenaQueryCssModulesValueClosureEdgeV0>,
311 pub icss_closure_edges: Vec<OmenaQueryCssModulesIcssClosureEdgeV0>,
312 pub cycles: Vec<OmenaQueryCssModulesCycleV0>,
313 pub capabilities: OmenaQueryCssModulesCrossFileResolutionCapabilitiesV0,
314 pub next_priorities: Vec<&'static str>,
315}
316
317#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
318#[serde(rename_all = "camelCase")]
319pub struct OmenaQueryCssModulesImportEdgeResolutionV0 {
320 pub from_style_path: String,
321 pub import_kind: &'static str,
322 pub source: String,
323 pub resolved_style_path: Option<String>,
324 pub status: &'static str,
325 pub import_graph_distance: Option<usize>,
326 pub import_graph_order: Option<usize>,
327 pub imported_names: Vec<String>,
328 pub exported_names: Vec<String>,
329 pub matched_names: Vec<String>,
330}
331
332#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
333#[serde(rename_all = "camelCase")]
334pub struct OmenaQueryCssModulesComposesClosureEdgeV0 {
335 pub from_style_path: String,
336 pub owner_selector_name: String,
337 pub target_style_path: String,
338 pub target_selector_name: String,
339 pub depth: usize,
340 pub path: Vec<String>,
341}
342
343#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
344#[serde(rename_all = "camelCase")]
345pub struct OmenaQueryCssModulesValueClosureEdgeV0 {
346 pub from_style_path: String,
347 pub value_name: String,
348 pub target_style_path: String,
349 pub target_value_name: String,
350 pub depth: usize,
351 pub path: Vec<String>,
352}
353
354#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
355#[serde(rename_all = "camelCase")]
356pub struct OmenaQueryCssModulesIcssClosureEdgeV0 {
357 pub from_style_path: String,
358 pub name: String,
359 pub target_style_path: String,
360 pub target_name: String,
361 pub depth: usize,
362 pub path: Vec<String>,
363}
364
365#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
366#[serde(rename_all = "camelCase")]
367pub struct OmenaQueryCssModulesCycleV0 {
368 pub kind: &'static str,
369 pub path: Vec<String>,
370}
371
372#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
373#[serde(rename_all = "camelCase")]
374pub struct OmenaQueryCssModulesCrossFileResolutionCapabilitiesV0 {
375 pub import_source_resolution_ready: bool,
376 pub composes_name_match_ready: bool,
377 pub value_name_match_ready: bool,
378 pub icss_name_match_ready: bool,
379 pub transitive_closure_ready: bool,
380 pub value_graph_closure_ready: bool,
381 pub icss_export_import_closure_ready: bool,
382 pub cycle_detection_ready: bool,
383}
384
385#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
386#[serde(rename_all = "camelCase")]
387pub struct OmenaQuerySassModuleCrossFileResolutionV0 {
388 pub schema_version: &'static str,
389 pub product: &'static str,
390 pub status: &'static str,
391 pub resolution_scope: &'static str,
392 pub style_count: usize,
393 pub module_edge_count: usize,
394 pub resolved_module_edge_count: usize,
395 pub unresolved_module_edge_count: usize,
396 pub external_module_edge_count: usize,
397 pub edges: Vec<OmenaQuerySassModuleEdgeResolutionV0>,
398 pub graph_closure_edge_count: usize,
399 pub cycle_count: usize,
400 pub visibility_filter_count: usize,
401 pub graph_closure_edges: Vec<OmenaQuerySassModuleGraphClosureEdgeV0>,
402 pub cycles: Vec<OmenaQuerySassModuleCycleV0>,
403 pub capabilities: OmenaQuerySassModuleCrossFileResolutionCapabilitiesV0,
404 pub next_priorities: Vec<&'static str>,
405}
406
407#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
408#[serde(rename_all = "camelCase")]
409pub struct OmenaQuerySassModuleEdgeResolutionV0 {
410 pub from_style_path: String,
411 pub edge_kind: &'static str,
412 pub source: String,
413 pub namespace_kind: Option<&'static str>,
414 pub namespace: Option<String>,
415 pub forward_prefix: Option<String>,
416 pub visibility_filter_kind: Option<&'static str>,
417 pub visibility_filter_names: Vec<String>,
418 pub resolved_style_path: Option<String>,
419 pub status: &'static str,
420 pub resolution_kind: &'static str,
421 pub candidate_count: usize,
422}
423
424#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
425#[serde(rename_all = "camelCase")]
426pub struct OmenaQuerySassModuleGraphClosureEdgeV0 {
427 pub from_style_path: String,
428 pub target_style_path: String,
429 pub edge_kind: &'static str,
430 pub depth: usize,
431 pub path: Vec<String>,
432 pub namespace_kind: Option<&'static str>,
433 pub namespace: Option<String>,
434 pub forward_prefix: Option<String>,
435 pub visibility_filter_kind: Option<&'static str>,
436 pub visibility_filter_names: Vec<String>,
437}
438
439#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
440#[serde(rename_all = "camelCase")]
441pub struct OmenaQuerySassModuleCycleV0 {
442 pub path: Vec<String>,
443}
444
445#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
446#[serde(rename_all = "camelCase")]
447pub struct OmenaQuerySassModuleCrossFileResolutionCapabilitiesV0 {
448 pub omena_parser_module_edge_consumption_ready: bool,
449 pub resolver_backed_source_resolution_ready: bool,
450 pub package_manifest_resolution_ready: bool,
451 pub external_module_filtering_ready: bool,
452 pub graph_closure_ready: bool,
453 pub cycle_detection_ready: bool,
454 pub namespace_show_hide_filter_ready: bool,
455}
456
457#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
458#[serde(rename_all = "camelCase")]
459pub struct OmenaQueryStyleDocumentSummaryV0 {
460 pub schema_version: &'static str,
461 pub product: &'static str,
462 pub language: &'static str,
463 pub selector_names: Vec<String>,
464 pub custom_property_decl_names: Vec<String>,
465 pub custom_property_ref_names: Vec<String>,
466 pub sass_module_use_sources: Vec<String>,
467 pub sass_module_forward_sources: Vec<String>,
468 pub diagnostic_count: usize,
469}
470
471#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
472#[serde(rename_all = "camelCase")]
473pub struct FastFactsV0 {
474 pub schema_version: &'static str,
475 pub product: &'static str,
476 pub tier: &'static str,
477 pub style_path: String,
478 pub language: &'static str,
479 pub selector_count: usize,
480 pub custom_property_count: usize,
481 pub sass_symbol_count: usize,
482 pub module_edge_count: usize,
483 pub parser_error_count: usize,
484}
485
486#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
487#[serde(rename_all = "camelCase")]
488pub struct AnalyzedGraphV0 {
489 pub schema_version: &'static str,
490 pub product: &'static str,
491 pub tier: &'static str,
492 pub style_path: String,
493 pub fast_facts: FastFactsV0,
494 pub graph_kinds: Vec<&'static str>,
495 pub node_count: usize,
496 pub edge_count: usize,
497 pub cycle_count: usize,
498}
499
500#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
501#[serde(rename_all = "camelCase")]
502pub struct StyleEditDistanceSummaryV0 {
503 pub schema_version: &'static str,
504 pub product: &'static str,
505 pub tier: &'static str,
506 pub metric_kind: &'static str,
507 pub claim_level: &'static str,
508 pub public_safety_claim_ready: bool,
509 pub left_style_path: String,
510 pub right_style_path: String,
511 pub left_fast_facts: FastFactsV0,
512 pub right_fast_facts: FastFactsV0,
513 pub left_analyzed_graph: AnalyzedGraphV0,
514 pub right_analyzed_graph: AnalyzedGraphV0,
515 pub selector_delta: usize,
516 pub custom_property_delta: usize,
517 pub sass_symbol_delta: usize,
518 pub module_edge_delta: usize,
519 pub parser_error_delta: usize,
520 pub graph_node_delta: usize,
521 pub graph_edge_delta: usize,
522 pub graph_cycle_delta: usize,
523 pub total_distance: usize,
524}
525
526#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
527#[serde(rename_all = "camelCase")]
528pub struct StyleEditDistanceCascadeMarginBridgeV0 {
529 pub schema_version: &'static str,
530 pub product: &'static str,
531 pub bridge_kind: &'static str,
532 pub claim_level: &'static str,
533 pub theorem_claimed: bool,
534 pub public_safety_claim_ready: bool,
535 pub metric_product: &'static str,
536 pub metric_kind: &'static str,
537 pub margin_product: &'static str,
538 pub margin_kind: &'static str,
539 pub dominant_axis: &'static str,
540 pub edit_distance_total: usize,
541 pub cascade_margin_signed_distance: i64,
542 pub cascade_margin_abs_distance: u64,
543 pub lipschitz_constant_name: &'static str,
544 pub lipschitz_constant: Option<u64>,
545 pub lipschitz_bound: Option<u64>,
546 pub checked: bool,
547 pub calibration_stage: &'static str,
548}
549
550#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
551#[serde(rename_all = "camelCase")]
552pub struct OmenaQueryCustomPropertyAnnotationSummaryV0 {
553 pub schema_version: &'static str,
554 pub product: &'static str,
555 pub style_path: String,
556 pub annotation_count: usize,
557 pub annotations: Vec<OmenaQueryCustomPropertyAnnotationV0>,
558}
559
560#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
561#[serde(rename_all = "camelCase")]
562pub struct OmenaQueryCustomPropertyAnnotationV0 {
563 pub name: String,
564 pub declaration_count: usize,
565 pub reference_count: usize,
566 pub annotation_kind: &'static str,
567 pub participates_in_fixed_point: bool,
568}
569
570#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
571#[serde(rename_all = "camelCase")]
572pub struct OmenaQueryStyleContextIndexV0 {
573 pub schema_version: &'static str,
574 pub product: &'static str,
575 pub style_path: String,
576 pub language: &'static str,
577 pub context_index_source: &'static str,
578 pub context_index: StyleContextIndexV0,
579}
580
581#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
582#[serde(rename_all = "camelCase")]
583pub struct OmenaQueryConsumerCheckSummaryV0 {
584 pub schema_version: &'static str,
585 pub product: &'static str,
586 pub style_path: String,
587 pub dialect: &'static str,
588 pub token_count: usize,
589 pub parser_error_count: usize,
590 pub class_selector_count: usize,
591 pub custom_property_count: usize,
592 pub keyframe_count: usize,
593 pub ready_surfaces: Vec<&'static str>,
594}
595
596#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
597#[serde(rename_all = "camelCase")]
598pub struct OmenaQueryConsumerBuildSummaryV0 {
599 pub schema_version: &'static str,
600 pub product: &'static str,
601 pub style_path: String,
602 pub dialect: &'static str,
603 pub requested_pass_ids: Vec<String>,
604 pub target_query: Option<OmenaQueryTransformTargetQueryPlanV0>,
605 pub unknown_pass_ids: Vec<String>,
606 pub execution: TransformExecutionSummaryV0,
607 pub semantic_removal_count: usize,
608 pub ready_surfaces: Vec<&'static str>,
609}
610
611#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
612#[serde(rename_all = "camelCase")]
613pub struct OmenaQueryTransformPassSummaryV0 {
614 pub id: &'static str,
615 pub title: &'static str,
616 pub reads_semantic_graph: bool,
617 pub reads_cascade_model: bool,
618}
619
620#[derive(Debug, Clone, PartialEq, Serialize)]
621#[serde(rename_all = "camelCase")]
622pub struct OmenaQueryTransformPlanSummaryV0 {
623 pub schema_version: &'static str,
624 pub product: &'static str,
625 pub style_path: String,
626 pub dialect: &'static str,
627 pub bundle: TransformBundleSourceSummaryV0,
628 pub target: TransformTargetPlanV0,
629 pub target_query: Option<OmenaQueryTransformTargetQueryPlanV0>,
630 pub egg: TransformEggPlanV0,
631 pub egg_witnesses: Vec<EggRewriteSourceWitnessV0>,
632 pub custom_property_fixed_point: OmenaQueryCustomPropertyLeastFixedPointSummaryV0,
633 pub print: TransformPrintArtifactV0,
634 pub execution: TransformExecutionSummaryV0,
635 pub semantic_removal_count: usize,
636 pub combined_plan: TransformPassPlanV0,
637 pub combined_pass_ids: Vec<&'static str>,
638 pub combined_violated_dag_edge_count: usize,
639 pub ready_surfaces: Vec<&'static str>,
640}
641
642#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
643#[serde(rename_all = "camelCase")]
644pub struct OmenaQueryTransformExecuteSummaryV0 {
645 pub schema_version: &'static str,
646 pub product: &'static str,
647 pub style_path: String,
648 pub requested_pass_ids: Vec<String>,
649 pub unknown_pass_ids: Vec<String>,
650 pub execution: TransformExecutionSummaryV0,
651 pub semantic_removal_count: usize,
652 pub ready_surfaces: Vec<&'static str>,
653}
654
655#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
656#[serde(rename_all = "camelCase")]
657pub struct OmenaQueryTransformContextFromSourcesSummaryV0 {
658 pub schema_version: &'static str,
659 pub product: &'static str,
660 pub target_style_path: String,
661 pub style_count: usize,
662 pub context: TransformExecutionContextV0,
663 pub import_inline_count: usize,
664 pub class_name_rewrite_count: usize,
665 pub css_module_composes_resolution_count: usize,
666 pub css_module_value_resolution_count: usize,
667 pub design_token_route_count: usize,
668 pub reachable_class_name_count: usize,
669 pub reachable_keyframe_name_count: usize,
670 pub reachable_value_name_count: usize,
671 pub reachable_custom_property_name_count: usize,
672 pub ready_surfaces: Vec<&'static str>,
673}
674
675#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
676#[serde(rename_all = "camelCase")]
677pub struct OmenaQueryTransformContextFromEngineInputSummaryV0 {
678 pub schema_version: &'static str,
679 pub product: &'static str,
680 pub input_version: String,
681 pub target_style_path: String,
682 pub closed_style_world: bool,
683 pub style_source_count: usize,
684 pub projection_count: usize,
685 pub selected_projection_count: usize,
686 pub import_inline_count: usize,
687 pub class_name_rewrite_count: usize,
688 pub css_module_composes_resolution_count: usize,
689 pub css_module_value_resolution_count: usize,
690 pub design_token_route_count: usize,
691 pub reachable_class_name_count: usize,
692 pub reachable_keyframe_name_count: usize,
693 pub reachable_value_name_count: usize,
694 pub reachable_custom_property_name_count: usize,
695 pub reachability_sources: Vec<OmenaQuerySemanticReachabilitySourceV0>,
696 pub context: TransformExecutionContextV0,
697 pub ready_surfaces: Vec<&'static str>,
698}
699
700#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
701#[serde(rename_all = "camelCase")]
702pub struct OmenaQuerySemanticReachabilitySourceV0 {
703 pub graph_id: String,
704 pub file_path: String,
705 pub node_id: String,
706 pub target_style_paths: Vec<String>,
707 pub value_kind: &'static str,
708 #[serde(skip_serializing_if = "Option::is_none")]
709 pub reduced_product: Option<ReducedClassValueProductV0>,
710 pub selector_names: Vec<String>,
711 pub certainty: SelectorProjectionCertaintyV0,
712}
713
714#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
715#[serde(rename_all = "camelCase")]
716pub struct OmenaQueryStyleSourceInputV0 {
717 pub style_path: String,
718 pub style_source: String,
719}
720
721#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
722#[serde(rename_all = "camelCase")]
723pub struct OmenaQueryExternalSifInputV0 {
724 pub canonical_url: String,
725 pub sif: OmenaSifV1,
726}
727
728#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
729#[serde(rename_all = "camelCase")]
730pub struct OmenaQuerySourceDocumentInputV0 {
731 pub source_path: String,
732 pub source_source: String,
733}
734
735#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
736#[serde(rename_all = "camelCase")]
737pub struct OmenaQueryOmenaParserStyleFactsV0 {
738 pub schema_version: &'static str,
739 pub product: &'static str,
740 pub dialect: &'static str,
741 pub class_selector_names: Vec<String>,
742 pub id_selector_names: Vec<String>,
743 pub placeholder_selector_names: Vec<String>,
744 pub keyframe_names: Vec<String>,
745 pub animation_reference_names: Vec<String>,
746 pub css_module_value_definition_names: Vec<String>,
747 pub css_module_value_reference_names: Vec<String>,
748 pub css_module_value_import_sources: Vec<String>,
749 pub css_module_value_import_edges: Vec<OmenaQueryCssModuleValueImportEdgeFactV0>,
750 pub css_module_value_definition_edges: Vec<OmenaQueryCssModuleValueDefinitionEdgeFactV0>,
751 pub css_module_composes_target_names: Vec<String>,
752 pub css_module_composes_import_sources: Vec<String>,
753 pub css_module_composes_edges: Vec<OmenaQueryCssModuleComposesEdgeFactV0>,
754 pub icss_export_names: Vec<String>,
755 pub icss_import_local_names: Vec<String>,
756 pub icss_import_remote_names: Vec<String>,
757 pub icss_import_sources: Vec<String>,
758 pub icss_import_edges: Vec<OmenaQueryIcssImportEdgeFactV0>,
759 pub icss_export_edges: Vec<OmenaQueryIcssExportEdgeFactV0>,
760 pub variable_names: Vec<String>,
761 pub sass_symbol_declaration_names: Vec<String>,
762 pub sass_symbol_reference_names: Vec<String>,
763 pub sass_symbol_facts: Vec<OmenaQuerySassSymbolFactV0>,
764 pub sass_symbol_resolution: OmenaQuerySassSymbolResolutionV0,
765 pub sass_module_use_sources: Vec<String>,
766 pub sass_module_forward_sources: Vec<String>,
767 pub sass_module_import_sources: Vec<String>,
768 pub sass_module_edges: Vec<OmenaQuerySassModuleEdgeFactV0>,
769 pub custom_property_names: Vec<String>,
770 pub custom_property_decl_names: Vec<String>,
771 pub custom_property_ref_names: Vec<String>,
772 pub at_rule_names: Vec<String>,
773 pub parser_error_count: usize,
774}
775
776#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
777#[serde(rename_all = "camelCase")]
778pub struct OmenaQuerySassSymbolFactV0 {
779 pub kind: &'static str,
780 pub symbol_kind: &'static str,
781 pub name: String,
782 pub role: &'static str,
783 pub namespace: Option<String>,
784}
785
786#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
787#[serde(rename_all = "camelCase")]
788pub struct OmenaQuerySassSymbolResolutionV0 {
789 pub schema_version: &'static str,
790 pub product: &'static str,
791 pub resolution_scope: &'static str,
792 pub declaration_count: usize,
793 pub reference_count: usize,
794 pub resolved_reference_count: usize,
795 pub unresolved_reference_count: usize,
796 pub edges: Vec<OmenaQuerySassSymbolResolutionEdgeV0>,
797 pub capabilities: OmenaQuerySassSymbolResolutionCapabilitiesV0,
798}
799
800#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
801#[serde(rename_all = "camelCase")]
802pub struct OmenaQuerySassSymbolResolutionEdgeV0 {
803 pub symbol_kind: &'static str,
804 pub name: String,
805 pub namespace: Option<String>,
806 pub reference_kind: &'static str,
807 pub reference_role: &'static str,
808 pub reference_source_order: usize,
809 pub declaration_kind: Option<&'static str>,
810 pub declaration_source_order: Option<usize>,
811 pub status: &'static str,
812}
813
814#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
815#[serde(rename_all = "camelCase")]
816pub struct OmenaQuerySassSymbolResolutionCapabilitiesV0 {
817 pub same_file_lexical_resolution_ready: bool,
818 pub declaration_before_reference_ready: bool,
819 pub unresolved_reference_reporting_ready: bool,
820 pub cross_file_module_resolution_ready: bool,
821}
822
823#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
824#[serde(rename_all = "camelCase")]
825pub struct OmenaQuerySassModuleEdgeFactV0 {
826 pub kind: &'static str,
827 pub source: String,
828 pub namespace_kind: Option<&'static str>,
829 pub namespace: Option<String>,
830 pub forward_prefix: Option<String>,
831 pub visibility_filter_kind: Option<&'static str>,
832 pub visibility_filter_names: Vec<String>,
833}
834
835#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
836#[serde(rename_all = "camelCase")]
837pub struct OmenaQueryCssModuleValueImportEdgeFactV0 {
838 pub remote_name: String,
839 pub local_name: String,
840 pub import_source: String,
841}
842
843#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
844#[serde(rename_all = "camelCase")]
845pub struct OmenaQueryCssModuleValueDefinitionEdgeFactV0 {
846 pub definition_name: String,
847 pub reference_names: Vec<String>,
848}
849
850#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
851#[serde(rename_all = "camelCase")]
852pub struct OmenaQueryCssModuleComposesEdgeFactV0 {
853 pub kind: &'static str,
854 pub owner_selector_names: Vec<String>,
855 pub target_names: Vec<String>,
856 pub import_source: Option<String>,
857}
858
859#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
860#[serde(rename_all = "camelCase")]
861pub struct OmenaQueryIcssImportEdgeFactV0 {
862 pub local_name: String,
863 pub remote_name: String,
864 pub import_source: String,
865}
866
867#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
868#[serde(rename_all = "camelCase")]
869pub struct OmenaQueryIcssExportEdgeFactV0 {
870 pub export_name: String,
871 pub reference_names: Vec<String>,
872}
873
874#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize)]
875#[serde(rename_all = "camelCase")]
876pub struct OmenaQueryStyleHoverCandidateV0 {
877 pub kind: &'static str,
878 pub name: String,
879 pub range: ParserRangeV0,
880 pub source: &'static str,
881 pub namespace: Option<String>,
882}
883
884#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
885#[serde(rename_all = "camelCase")]
886pub struct OmenaQueryStyleHoverCandidatesV0 {
887 pub schema_version: &'static str,
888 pub product: &'static str,
889 pub language: &'static str,
890 pub candidates: Vec<OmenaQueryStyleHoverCandidateV0>,
891}
892
893#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
894#[serde(rename_all = "camelCase")]
895pub struct OmenaQueryStyleHoverRenderPartsV0 {
896 pub schema_version: &'static str,
897 pub product: &'static str,
898 pub snippet: String,
899 pub value: Option<String>,
900 pub signature: Option<String>,
901 pub render_source: &'static str,
902}
903
904#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
905#[serde(rename_all = "camelCase")]
906pub struct OmenaQueryStyleDiagnosticV0 {
907 pub code: &'static str,
908 pub severity: &'static str,
909 pub provenance: Vec<&'static str>,
910 pub range: ParserRangeV0,
911 pub message: String,
912 #[serde(skip_serializing_if = "Vec::is_empty")]
913 pub tags: Vec<u8>,
914 pub create_custom_property: Option<OmenaQueryCreateCustomPropertyActionV0>,
915}
916
917pub type OmenaQueryLinearProvenanceV0 = LinearProvenanceV0<Lin01ProvenanceSemiringV0>;
918
919pub fn summarize_omena_query_linear_provenance(
920 provenance: &[&'static str],
921) -> OmenaQueryLinearProvenanceV0 {
922 OmenaQueryLinearProvenanceV0::from_static_labels(provenance)
923}
924
925pub fn round_trip_omena_query_linear_provenance_labels(
926 linear_provenance: &OmenaQueryLinearProvenanceV0,
927) -> Vec<&'static str> {
928 linear_provenance.labels()
929}
930
931impl OmenaQueryCrossFileSummaryEdgeV0 {
932 pub fn linear_provenance_round_trips_legacy_labels(&self) -> bool {
933 round_trip_omena_query_linear_provenance_labels(&self.linear_provenance) == self.provenance
934 }
935}
936
937impl OmenaQueryCrossFileSummaryV0 {
938 pub fn linear_provenance_round_trips_legacy_labels(&self) -> bool {
939 self.edges
940 .iter()
941 .all(OmenaQueryCrossFileSummaryEdgeV0::linear_provenance_round_trips_legacy_labels)
942 }
943}
944
945impl OmenaQueryStyleDiagnosticV0 {
946 pub fn linear_provenance(&self) -> OmenaQueryLinearProvenanceV0 {
947 summarize_omena_query_linear_provenance(self.provenance.as_slice())
948 }
949}
950
951#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
952#[serde(rename_all = "camelCase")]
953pub struct OmenaQueryStyleDiagnosticsForFileV0 {
954 pub schema_version: &'static str,
955 pub product: &'static str,
956 pub file_uri: String,
957 pub file_kind: &'static str,
958 pub diagnostic_count: usize,
959 pub diagnostics: Vec<OmenaQueryStyleDiagnosticV0>,
960 pub ready_surfaces: Vec<&'static str>,
961}
962
963#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
964#[serde(rename_all = "camelCase")]
965pub struct OmenaQueryCompletionCandidateV0 {
966 pub file_uri: String,
967 pub name: String,
968 pub kind: &'static str,
969 pub range: ParserRangeV0,
970 pub source: &'static str,
971}
972
973#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
974#[serde(rename_all = "camelCase")]
975pub struct OmenaQueryCompletionItemV0 {
976 pub label: String,
977 pub insert_text: String,
978 pub sort_text: String,
979 pub detail: &'static str,
980 pub item_kind: &'static str,
981 pub ranking_source: &'static str,
982 pub source: &'static str,
983}
984
985#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
986#[serde(rename_all = "camelCase")]
987pub struct OmenaQueryCompletionAtPositionV0 {
988 pub schema_version: &'static str,
989 pub product: &'static str,
990 pub file_uri: String,
991 pub file_kind: &'static str,
992 pub query_position: ParserPositionV0,
993 pub context_kind: &'static str,
994 pub prefix: Option<String>,
995 pub is_incomplete: bool,
996 pub item_count: usize,
997 pub items: Vec<OmenaQueryCompletionItemV0>,
998 pub ready_surfaces: Vec<&'static str>,
999}
1000
1001#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1002#[serde(rename_all = "camelCase")]
1003pub struct OmenaQueryReferenceLocationV0 {
1004 pub uri: String,
1005 pub range: ParserRangeV0,
1006 pub name: String,
1007 pub role: &'static str,
1008 pub source: &'static str,
1009}
1010
1011#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1012#[serde(rename_all = "camelCase")]
1013pub struct OmenaQueryRefsForClassV0 {
1014 pub schema_version: &'static str,
1015 pub product: &'static str,
1016 pub selector_name: String,
1017 pub target_style_uri: Option<String>,
1018 pub include_declaration: bool,
1019 pub location_count: usize,
1020 pub locations: Vec<OmenaQueryReferenceLocationV0>,
1021 pub ready_surfaces: Vec<&'static str>,
1022}
1023
1024#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1025#[serde(rename_all = "camelCase")]
1026pub struct OmenaQueryRenamePlanV0 {
1027 pub schema_version: &'static str,
1028 pub product: &'static str,
1029 pub selector_name: String,
1030 pub new_name: String,
1031 pub target_style_uri: Option<String>,
1032 pub edit_count: usize,
1033 pub edits: Vec<OmenaQueryWorkspaceTextEditV0>,
1034 pub ready_surfaces: Vec<&'static str>,
1035}
1036
1037#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1038#[serde(rename_all = "camelCase")]
1039pub struct OmenaQueryCodeActionPlanV0 {
1040 pub schema_version: &'static str,
1041 pub product: &'static str,
1042 pub file_uri: String,
1043 pub file_kind: &'static str,
1044 pub action_count: usize,
1045 pub actions: Vec<OmenaQueryCodeActionV0>,
1046 pub ready_surfaces: Vec<&'static str>,
1047}
1048
1049#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1050#[serde(rename_all = "camelCase")]
1051pub struct OmenaQueryCodeActionV0 {
1052 pub title: String,
1053 pub kind: &'static str,
1054 pub edits: Vec<OmenaQueryWorkspaceTextEditV0>,
1055 pub source: &'static str,
1056}
1057
1058#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1059#[serde(rename_all = "camelCase")]
1060pub struct OmenaQueryCascadeAtPositionV0 {
1061 pub schema_version: &'static str,
1062 pub product: &'static str,
1063 pub style_path: String,
1064 pub query_position: ParserPositionV0,
1065 pub status: &'static str,
1066 pub cascade_engine: &'static str,
1067 pub reference_name: Option<String>,
1068 pub reference_range: Option<ParserRangeV0>,
1069 pub winner_declaration_source_order: Option<usize>,
1070 pub winner_declaration_file_path: Option<String>,
1071 pub winner_declaration_range: Option<ParserRangeV0>,
1072 pub winner_context_kind: Option<&'static str>,
1073 pub winner_declaration_layer_rank: Option<i32>,
1074 pub winner_declaration_layer_name: Option<String>,
1075 pub candidate_declaration_count: usize,
1076 pub shadowed_declaration_source_orders: Vec<usize>,
1077 pub referenced_declaration_property: Option<String>,
1078 pub referenced_declaration_value: Option<String>,
1079 pub referenced_declaration_computed_value_status: Option<&'static str>,
1080 pub referenced_declaration_computed_value: Option<String>,
1081 pub referenced_declaration_invalid_at_computed_value_time: bool,
1082 pub referenced_declaration_computed_value_derivation_steps: Vec<&'static str>,
1083 pub custom_property_fixed_point_iteration_count: usize,
1084 pub custom_property_fixed_point_guaranteed_invalid_count: usize,
1085 pub reference_custom_property_fixed_point_status: Option<&'static str>,
1086 pub reference_custom_property_fixed_point_value: Option<String>,
1087 #[serde(skip_serializing_if = "Option::is_none")]
1088 pub categorical_evidence: Option<omena_categorical::CategoricalCascadeEvidenceV0>,
1089}
1090
1091#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1092#[serde(rename_all = "camelCase")]
1093pub struct OmenaQueryCreateCustomPropertyActionV0 {
1094 pub uri: String,
1095 pub range: ParserRangeV0,
1096 pub new_text: String,
1097 pub property_name: String,
1098}
1099
1100#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1101#[serde(rename_all = "camelCase")]
1102pub struct OmenaQuerySourceDiagnosticV0 {
1103 pub code: &'static str,
1104 pub severity: &'static str,
1105 pub provenance: Vec<&'static str>,
1106 pub range: ParserRangeV0,
1107 pub message: String,
1108 pub create_selector: Option<OmenaQueryCreateSelectorActionV0>,
1109}
1110
1111impl OmenaQuerySourceDiagnosticV0 {
1112 pub fn linear_provenance(&self) -> OmenaQueryLinearProvenanceV0 {
1113 summarize_omena_query_linear_provenance(self.provenance.as_slice())
1114 }
1115}
1116
1117#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1118#[serde(rename_all = "camelCase")]
1119pub struct OmenaQueryCreateSelectorActionV0 {
1120 pub uri: String,
1121 pub range: ParserRangeV0,
1122 pub new_text: String,
1123 pub selector_name: String,
1124}
1125
1126#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
1127#[serde(rename_all = "camelCase")]
1128pub struct OmenaQuerySourceMissingSelectorDiagnosticCandidateV0 {
1129 pub target_style_uri: String,
1130 pub target_style_source: String,
1131 pub selector_name: String,
1132 pub source_reference_range: ParserRangeV0,
1133}
1134
1135#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1136#[serde(rename_all = "camelCase")]
1137pub struct OmenaQuerySourceDiagnosticsForFileV0 {
1138 pub schema_version: &'static str,
1139 pub product: &'static str,
1140 pub file_uri: String,
1141 pub file_kind: &'static str,
1142 pub diagnostic_count: usize,
1143 pub diagnostics: Vec<OmenaQuerySourceDiagnosticV0>,
1144 pub ready_surfaces: Vec<&'static str>,
1145}
1146
1147#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize)]
1148#[serde(rename_all = "camelCase")]
1149pub struct OmenaQuerySourceSelectorCandidateV0 {
1150 pub kind: &'static str,
1151 pub name: String,
1152 pub range: ParserRangeV0,
1153 pub source: &'static str,
1154 pub target_style_uri: Option<String>,
1155}
1156
1157#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize)]
1158#[serde(rename_all = "camelCase")]
1159pub struct OmenaQuerySourceSelectorReferenceCandidateV0 {
1160 pub uri: String,
1161 pub kind: &'static str,
1162 pub name: String,
1163 pub range: ParserRangeV0,
1164 pub source: &'static str,
1165 pub target_style_uri: Option<String>,
1166}
1167
1168#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1169#[serde(rename_all = "camelCase")]
1170pub struct OmenaQueryStyleSelectorDefinitionV0 {
1171 pub uri: String,
1172 pub name: String,
1173 pub range: ParserRangeV0,
1174}
1175
1176#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1177#[serde(rename_all = "camelCase")]
1178pub struct OmenaQuerySourceProviderCandidateResolutionV0 {
1179 pub schema_version: &'static str,
1180 pub product: &'static str,
1181 pub matched: Vec<OmenaQuerySourceSelectorCandidateV0>,
1182 pub unresolved: Vec<OmenaQuerySourceSelectorCandidateV0>,
1183}
1184
1185#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1186#[serde(rename_all = "camelCase")]
1187pub struct OmenaQuerySourceSelectorReferenceEditTargetV0 {
1188 pub uri: String,
1189 pub name: String,
1190 pub range: ParserRangeV0,
1191 pub target_style_uri: Option<String>,
1192}
1193
1194#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1195#[serde(rename_all = "camelCase")]
1196pub struct OmenaQueryWorkspaceTextEditV0 {
1197 pub uri: String,
1198 pub range: ParserRangeV0,
1199 pub new_text: String,
1200}
1201
1202#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1203#[serde(rename_all = "camelCase")]
1204pub struct OmenaQuerySassModuleUseEdgeV0 {
1205 pub source: String,
1206 pub namespace_kind: &'static str,
1207 pub namespace: Option<String>,
1208}
1209
1210#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1211#[serde(rename_all = "camelCase")]
1212pub struct OmenaQuerySassModuleSourcesV0 {
1213 pub schema_version: &'static str,
1214 pub product: &'static str,
1215 pub module_use_edges: Vec<OmenaQuerySassModuleUseEdgeV0>,
1216 pub module_forward_sources: Vec<String>,
1217}
1218
1219#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
1220#[serde(rename_all = "camelCase")]
1221pub struct OmenaQueryStylePackageManifestV0 {
1222 pub package_json_path: String,
1223 pub package_json_source: String,
1224}
1225
1226#[derive(Debug, Serialize)]
1227#[serde(rename_all = "camelCase")]
1228pub struct OmenaQueryExpressionDomainIncrementalFlowAnalysisV0 {
1229 pub schema_version: &'static str,
1230 pub product: &'static str,
1231 pub input_version: String,
1232 pub revision: u64,
1233 pub graph_count: usize,
1234 pub dirty_graph_count: usize,
1235 pub reused_graph_count: usize,
1236 pub analyses: Vec<OmenaQueryExpressionDomainIncrementalFlowAnalysisEntryV0>,
1237}
1238
1239#[derive(Debug, Serialize)]
1240#[serde(rename_all = "camelCase")]
1241pub struct OmenaQueryExpressionDomainIncrementalFlowAnalysisEntryV0 {
1242 pub graph_id: String,
1243 pub file_path: String,
1244 pub analysis: ClassValueFlowIncrementalAnalysisV0,
1245}
1246
1247#[derive(Debug, Serialize)]
1248#[serde(rename_all = "camelCase")]
1249pub struct OmenaQueryExpressionDomainSelectorProjectionV0 {
1250 pub schema_version: &'static str,
1251 pub product: &'static str,
1252 pub input_version: String,
1253 pub projection_count: usize,
1254 pub projections: Vec<OmenaQueryExpressionDomainSelectorProjectionEntryV0>,
1255}
1256
1257#[derive(Debug, Serialize)]
1258#[serde(rename_all = "camelCase")]
1259pub struct OmenaQueryExpressionDomainSelectorProjectionEntryV0 {
1260 pub graph_id: String,
1261 pub file_path: String,
1262 pub node_id: String,
1263 pub target_style_paths: Vec<String>,
1264 pub value_kind: &'static str,
1265 #[serde(skip_serializing_if = "Option::is_none")]
1266 pub reduced_product: Option<ReducedClassValueProductV0>,
1267 pub selector_names: Vec<String>,
1268 pub certainty: SelectorProjectionCertaintyV0,
1269}
1270
1271#[derive(Default)]
1272pub struct OmenaQueryExpressionDomainFlowRuntimeV0 {
1273 pub(crate) revision: u64,
1274 pub(crate) databases_by_graph_id: BTreeMap<String, OmenaIncrementalDatabaseV0>,
1275 pub(crate) previous_analyses_by_graph_id: BTreeMap<String, ClassValueFlowAnalysisV0>,
1276}