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