1use serde::{Deserialize, Deserializer, Serialize, Serializer};
2
3macro_rules! raw_preserving_string_enum {
4 (
5 $(#[$meta:meta])*
6 pub enum $name:ident {
7 $($variant:ident => $wire_value:literal),+ $(,)?
8 }
9 ) => {
10 $(#[$meta])*
11 #[derive(Debug, Clone, PartialEq, Eq)]
12 pub enum $name {
13 $($variant,)+
14 Unknown(String),
15 }
16
17 impl Serialize for $name {
18 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
19 where
20 S: Serializer,
21 {
22 let value = match self {
23 $(Self::$variant => $wire_value,)+
24 Self::Unknown(raw) => raw.as_str(),
25 };
26
27 serializer.serialize_str(value)
28 }
29 }
30
31 impl<'de> Deserialize<'de> for $name {
32 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
33 where
34 D: Deserializer<'de>,
35 {
36 let raw = String::deserialize(deserializer)?;
37 Ok(match raw.as_str() {
38 $($wire_value => Self::$variant,)+
39 _ => Self::Unknown(raw),
40 })
41 }
42 }
43 };
44}
45
46pub const ESP_DIAGNOSTICS_SCHEMA_VERSION: u32 = 1;
47
48#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
49#[serde(rename_all = "camelCase")]
50pub enum EspScenario {
51 Unknown,
52 AutopilotV1,
53 ExistingDeviceJson,
54 EspOnly,
55 AutopilotDevicePreparationV2,
56}
57
58#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
59#[serde(rename_all = "camelCase")]
60pub enum EspPhase {
61 NotStarted,
62 DevicePreparation,
63 DeviceSetup,
64 AccountSetup,
65 Completed,
66 Failed,
67 Unknown,
68}
69
70#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
71#[serde(rename_all = "camelCase")]
72pub enum EspTrackedKind {
73 Msi,
74 Office,
75 ModernApp,
76 Win32App,
77 Policy,
78 ScepCertificate,
79 PlatformScript,
80 DevicePreparationWorkload,
81}
82
83#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
84#[serde(rename_all = "camelCase")]
85pub enum EspNormalizedStatus {
86 NotStarted,
87 NotInstalled,
88 Initialized,
89 Pending,
90 Downloading,
91 Downloaded,
92 Installing,
93 InProgress,
94 Processed,
95 Succeeded,
96 Failed,
97 Skipped,
98 Uninstalled,
99 RebootRequired,
100 Cancelled,
101 Unknown,
102}
103
104#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
105#[serde(rename_all = "camelCase")]
106pub enum EspArtifactStatus {
107 Available,
108 Missing,
109 PermissionDenied,
110 ParseFailed,
111 Unsupported,
112}
113
114#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
115#[serde(rename_all = "camelCase")]
116pub enum EspCorrelationConfidence {
117 Exact,
118 Strong,
119 Temporal,
120 Uncorrelated,
121}
122
123#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
124#[serde(rename_all = "camelCase")]
125pub enum EspTimestampKind {
126 Utc,
127 Offset,
128 Local,
129 Unspecified,
130 Invalid,
131}
132
133#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
134#[serde(rename_all = "camelCase")]
135pub enum EspSourceKind {
136 Registry,
137 Json,
138 EventLog,
139 ImeLog,
140 DeploymentLog,
141 Process,
142 System,
143 DeliveryOptimization,
144 Graph,
145 Coverage,
146}
147
148#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
149#[serde(rename_all = "camelCase")]
150pub enum EspSensitivity {
151 Public,
152 Sensitive,
153 Restricted,
154}
155
156#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
157#[serde(rename_all = "camelCase")]
158pub struct EspClassifiedString {
159 pub value: String,
160 pub sensitivity: EspSensitivity,
161}
162
163#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
164#[serde(rename_all = "camelCase")]
165pub enum EspParseState {
166 Parsed,
167 Raw,
168 Malformed,
169 Unsupported,
170}
171
172#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
173#[serde(rename_all = "camelCase")]
174pub enum EspSourceAccessState {
175 Available,
176 Missing,
177 PermissionDenied,
178 Failed,
179 Unsupported,
180}
181
182#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
183#[serde(rename_all = "camelCase")]
184pub enum EspScope {
185 Device,
186 User,
187}
188
189#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
190#[serde(rename_all = "camelCase")]
191pub enum EspSessionKind {
192 Classic,
193 DevicePreparationV2,
194}
195
196raw_preserving_string_enum! {
197 pub enum EspJoinMode {
198 Entra => "entra",
199 HybridEntra => "hybridEntra",
200 }
201}
202
203#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
204#[serde(rename_all = "camelCase")]
205pub enum EspFindingSeverity {
206 Info,
207 Warning,
208 Error,
209 Blocker,
210}
211
212#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
213#[serde(rename_all = "camelCase")]
214pub enum EspFindingConfidence {
215 Low,
216 Medium,
217 High,
218}
219
220#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
221#[serde(rename_all = "camelCase")]
222pub enum EspTimelineKind {
223 ProfileDownload,
224 OfflineDomainJoin,
225 Registration,
226 Workload,
227 DeliveryOptimization,
228 Coverage,
229 Process,
230 Other,
231}
232
233raw_preserving_string_enum! {
234 pub enum EspGraphAssignmentIntent {
235 Required => "required",
236 Available => "available",
237 Uninstall => "uninstall",
238 }
239}
240
241raw_preserving_string_enum! {
242 pub enum EspGraphTargetKind {
243 AllDevices => "allDevices",
244 AllUsers => "allUsers",
245 Group => "group",
246 Filter => "filter",
247 }
248}
249
250#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
251#[serde(rename_all = "camelCase")]
252pub enum EspGraphTargeting {
253 Declared,
254 Effective,
255}
256
257raw_preserving_string_enum! {
258 pub enum EspGraphPolicyKind {
259 DeviceConfiguration => "deviceConfiguration",
260 Compliance => "compliance",
261 ConfigurationPolicy => "configurationPolicy",
262 ScepCertificate => "scepCertificate",
263 }
264}
265
266raw_preserving_string_enum! {
267 pub enum EspGraphScriptKind {
268 PlatformScript => "platformScript",
269 Remediation => "remediation",
270 }
271}
272
273raw_preserving_string_enum! {
274 pub enum EspGraphObservationSection {
275 ManagedDevice => "managedDevice",
276 AutopilotIdentity => "autopilotIdentity",
277 DeploymentProfile => "deploymentProfile",
278 EnrollmentConfiguration => "enrollmentConfiguration",
279 App => "app",
280 Policy => "policy",
281 Script => "script",
282 }
283}
284
285raw_preserving_string_enum! {
286 pub enum EspGraphPolicyStatusDetailKind {
287 App => "app",
288 Policy => "policy",
289 }
290}
291
292#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
293#[serde(rename_all = "camelCase")]
294pub enum EspDeliveryOptimizationEventKind {
295 DownloadStarted,
296 DownloadCompleted,
297}
298
299raw_preserving_string_enum! {
300 pub enum GraphSectionStatus {
301 Available => "available",
302 NotFound => "notFound",
303 PermissionDenied => "permissionDenied",
304 Failed => "failed",
305 Skipped => "skipped",
306 Cancelled => "cancelled",
307 }
308}
309
310raw_preserving_string_enum! {
311 pub enum GraphApiVersion {
312 V1_0 => "v1.0",
313 Beta => "beta",
314 NotRequested => "notRequested",
315 }
316}
317
318#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
319#[serde(untagged)]
320pub enum EspRawStatus {
321 Number(i64),
322 Text(String),
323 Other(serde_json::Value),
324}
325
326#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
327#[serde(rename_all = "camelCase")]
328pub enum EspObservationValue {
329 Text(String),
330 Integer(i64),
331 Unsigned(u64),
332 Boolean(bool),
333 StringList(Vec<String>),
334}
335
336#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
337#[serde(rename_all = "camelCase")]
338pub enum EspSystemFact {
339 OsVersion(String),
340 OsBuild(String),
341 Manufacturer(String),
342 Model(String),
343 SerialNumber(String),
344 TpmVersion(String),
345 Hostname(String),
346 EntraDeviceId(String),
347 TenantId(String),
348 JoinMode(EspJoinMode),
349 Elevation(EspElevationState),
350}
351
352#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
353#[serde(rename_all = "camelCase")]
354pub struct EspTimestamp {
355 pub raw_text: String,
356 pub original_offset: Option<String>,
357 pub normalized_utc: Option<String>,
358 pub kind: EspTimestampKind,
359}
360
361#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
362#[serde(rename_all = "camelCase")]
363pub struct EspEvidenceRef {
364 pub evidence_id: String,
365 pub source_artifact_id: String,
366}
367
368#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
369#[serde(rename_all = "camelCase")]
370pub struct EspRegistryProvenance {
371 pub hive: String,
372 pub key: String,
373 pub value_name: Option<String>,
374}
375
376#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
377#[serde(rename_all = "camelCase")]
378pub struct EspEventProvenance {
379 pub channel: String,
380 pub event_id: u32,
381 pub record_id: Option<u64>,
382 pub named_data: Vec<EspNamedValue>,
383}
384
385#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
386#[serde(rename_all = "camelCase")]
387pub struct EspEvidenceProvenance {
388 pub source_kind: EspSourceKind,
389 pub source_artifact_id: String,
390 pub file_path: Option<String>,
391 pub line_number: Option<u64>,
392 pub record_number: Option<u64>,
393 pub registry: Option<EspRegistryProvenance>,
394 pub event: Option<EspEventProvenance>,
395}
396
397#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
398#[serde(rename_all = "camelCase")]
399pub struct EspObservationContext {
400 pub evidence_ref: EspEvidenceRef,
401 pub provenance: EspEvidenceProvenance,
402 pub source_timestamp: Option<EspTimestamp>,
403 pub observed_at_utc: String,
404 pub sensitivity: EspSensitivity,
405 pub parse_state: EspParseState,
406 pub access_state: EspSourceAccessState,
407}
408
409#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
410#[serde(rename_all = "camelCase")]
411pub struct EspStatusDetail {
412 pub raw: EspRawStatus,
413 pub normalized: EspNormalizedStatus,
414 pub display: String,
415}
416
417#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
418#[serde(rename_all = "camelCase")]
419pub struct EspStatus {
420 pub raw: EspRawStatus,
421 pub normalized: EspNormalizedStatus,
422 pub display: String,
423 pub detail: Option<EspStatusDetail>,
424}
425
426#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
427#[serde(rename_all = "camelCase")]
428pub struct EspErrorCode {
429 pub raw: String,
430 pub decimal: Option<i64>,
431 pub hex: Option<String>,
432}
433
434#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
435#[serde(rename_all = "camelCase")]
436pub struct EspNamedValue {
437 pub name: String,
438 pub value: String,
439}
440
441#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
442#[serde(rename_all = "camelCase")]
443pub struct EspElevationState {
444 pub is_elevated: bool,
445 pub restart_supported: bool,
446 pub restricted_sources: Vec<String>,
447}
448
449#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
450#[serde(rename_all = "camelCase")]
451pub struct EspIdentityEvidence {
452 pub device_name: Option<String>,
453 pub managed_device_id: Option<String>,
454 pub entra_device_id: Option<String>,
455 pub entdm_id: Option<EspClassifiedString>,
456 pub tenant_id: Option<EspClassifiedString>,
457 pub tenant_domain: Option<EspClassifiedString>,
458 pub user_principal_name: Option<EspClassifiedString>,
459 pub serial_number: Option<EspClassifiedString>,
460 pub evidence: Vec<EspEvidenceRef>,
461}
462
463#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
464#[serde(rename_all = "camelCase")]
465pub struct EspOobeConfig {
466 pub raw_mask: u64,
467 pub skip_keyboard: bool,
468 pub enable_patch_download: bool,
469 pub skip_windows_upgrade_ux: bool,
470 pub aad_tpm_required: bool,
471 pub aad_device_authentication: bool,
472 pub tpm_attestation: bool,
473 pub skip_eula: bool,
474 pub skip_oem_registration: bool,
475 pub skip_express_settings: bool,
476 pub disallow_admin: bool,
477}
478
479#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
480#[serde(rename_all = "camelCase")]
481pub struct EspDevicePreparationEvidence {
482 pub agent_download_timeout_seconds: Option<u64>,
483 pub page_timeout_seconds: Option<u64>,
484 pub allow_skip_on_failure: Option<bool>,
485 pub allow_diagnostics: Option<bool>,
486 pub script_ids: Vec<String>,
487 pub evidence: Vec<EspEvidenceRef>,
488}
489
490#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
491#[serde(rename_all = "camelCase")]
492pub struct EspProfileEvidence {
493 pub profile_name: Option<String>,
494 pub deployment_profile_id: Option<String>,
495 pub correlation_id: Option<String>,
496 pub tenant_domain: Option<EspClassifiedString>,
497 pub tenant_id: Option<EspClassifiedString>,
498 pub oobe_config: Option<EspOobeConfig>,
499 pub profile_download_time: Option<EspTimestamp>,
500 pub join_mode: Option<EspJoinMode>,
501 pub odj_applied: Option<bool>,
502 pub skip_domain_connectivity_check: Option<bool>,
503 pub device_preparation: Option<EspDevicePreparationEvidence>,
504 pub evidence: Vec<EspEvidenceRef>,
505}
506
507#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
508#[serde(rename_all = "camelCase")]
509pub struct EspEnrollmentSettings {
510 pub device_esp_enabled: Option<bool>,
511 pub user_esp_enabled: Option<bool>,
512 pub timeout_seconds: Option<u64>,
513 pub blocking: Option<bool>,
514 pub allow_reset: Option<bool>,
515 pub allow_retry: Option<bool>,
516 pub continue_anyway: Option<bool>,
517}
518
519#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
520#[serde(rename_all = "camelCase")]
521pub struct EspEnrollmentEvidence {
522 pub enrollment_id: String,
523 pub provider_id: Option<String>,
524 pub tenant_id: Option<EspClassifiedString>,
525 pub user_principal_name: Option<EspClassifiedString>,
526 pub entdm_id: Option<EspClassifiedString>,
527 pub settings: EspEnrollmentSettings,
528 pub evidence: Vec<EspEvidenceRef>,
529}
530
531#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
532#[serde(rename_all = "camelCase")]
533pub struct EspSession {
534 pub session_id: String,
535 pub kind: EspSessionKind,
536 pub scope: EspScope,
537 pub user_sid: Option<EspClassifiedString>,
538 pub started_at: Option<EspTimestamp>,
539 pub ended_at: Option<EspTimestamp>,
540 pub phase: EspPhase,
541 pub is_latest: bool,
542 pub workload_ids: Vec<String>,
543 pub evidence: Vec<EspEvidenceRef>,
544}
545
546#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
547#[serde(rename_all = "camelCase")]
548pub struct EspWorkloadTimestamps {
549 pub first_observed: EspTimestamp,
550 pub started: Option<EspTimestamp>,
551 pub ended: Option<EspTimestamp>,
552 pub last_updated: Option<EspTimestamp>,
553}
554
555#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
556#[serde(rename_all = "camelCase")]
557pub struct EspWorkload {
558 pub workload_id: String,
559 pub session_id: String,
560 pub kind: EspTrackedKind,
561 pub scope: EspScope,
562 pub raw_identifier: String,
563 pub display_name: Option<String>,
564 pub status: EspStatus,
565 pub timestamps: EspWorkloadTimestamps,
566 pub exit_code: Option<EspErrorCode>,
567 pub enforcement_error_code: Option<EspErrorCode>,
568 pub blocking: Option<bool>,
569 pub evidence: Vec<EspEvidenceRef>,
570}
571
572#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
573#[serde(rename_all = "camelCase")]
574pub struct EspNodeCacheEntry {
575 pub index: u64,
576 pub node_uri: String,
577 pub expected_value: Option<String>,
578 pub sensitivity: EspSensitivity,
579 pub evidence: Vec<EspEvidenceRef>,
580}
581
582#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
583#[serde(rename_all = "camelCase")]
584pub struct EspRegistrationEvent {
585 pub event_id: u32,
586 pub record_id: Option<u64>,
587 pub status: EspStatus,
588 pub message: String,
589 pub timestamp: EspTimestamp,
590 pub named_data: Vec<EspNamedValue>,
591 pub evidence: Vec<EspEvidenceRef>,
592}
593
594#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
595#[serde(rename_all = "camelCase")]
596pub struct EspDeliveryOptimizationTransfer {
597 pub transfer_id: String,
598 pub kind: EspDeliveryOptimizationEventKind,
599 pub content_id: Option<String>,
600 pub app_id: Option<String>,
601 pub timestamp: EspTimestamp,
602 pub evidence: Vec<EspEvidenceRef>,
603}
604
605#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
606#[serde(rename_all = "camelCase")]
607pub struct EspDeliveryOptimizationEvidence {
608 pub download_http_bytes: u64,
609 pub download_lan_bytes: u64,
610 pub download_cache_host_bytes: u64,
611 pub peer_share_percent: Option<f64>,
612 pub connected_cache_share_percent: Option<f64>,
613 pub transfers: Vec<EspDeliveryOptimizationTransfer>,
614 pub evidence: Vec<EspEvidenceRef>,
615}
616
617#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
618#[serde(rename_all = "camelCase")]
619pub struct EspHardwareEvidence {
620 pub os_version: Option<String>,
621 pub os_build: Option<String>,
622 pub manufacturer: Option<String>,
623 pub model: Option<String>,
624 pub serial_number: Option<EspClassifiedString>,
625 pub tpm_version: Option<String>,
626 pub evidence: Vec<EspEvidenceRef>,
627}
628
629#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
630#[serde(rename_all = "camelCase")]
631pub struct EspTimelineEntry {
632 pub entry_id: String,
633 pub timestamp: EspTimestamp,
634 pub kind: EspTimelineKind,
635 pub title: String,
636 pub detail: Option<String>,
637 pub status: Option<EspStatus>,
638 pub evidence: Vec<EspEvidenceRef>,
639}
640
641#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
642#[serde(rename_all = "camelCase")]
643pub struct EspDiagnosticFinding {
644 pub finding_id: String,
645 pub severity: EspFindingSeverity,
646 pub confidence: EspFindingConfidence,
647 pub title: String,
648 pub summary: String,
649 pub recommended_checks: Vec<String>,
650 pub evidence: Vec<EspEvidenceRef>,
651 pub coverage_gap_ids: Vec<String>,
652}
653
654#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
655#[serde(rename_all = "camelCase")]
656pub struct EspArtifactCoverage {
657 pub artifact_id: String,
658 pub family: String,
659 pub status: EspArtifactStatus,
660 pub detail: Option<String>,
661 pub observed_at_utc: String,
662 pub evidence: Vec<EspEvidenceRef>,
663}
664
665#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
666#[serde(rename_all = "camelCase")]
667pub struct EspRawEvidenceRecord {
668 pub record_id: String,
669 pub provenance: EspEvidenceProvenance,
670 pub source_timestamp: Option<EspTimestamp>,
671 pub observed_at_utc: String,
672 pub raw_value: EspObservationValue,
673 pub sensitivity: EspSensitivity,
674 pub parse_state: EspParseState,
675 pub access_state: EspSourceAccessState,
676 pub evidence: Vec<EspEvidenceRef>,
677}
678
679#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
680#[serde(rename_all = "camelCase")]
681pub struct EspRegistryObservation {
682 pub context: EspObservationContext,
683 pub hive: String,
684 pub key: String,
685 pub value_name: String,
686 pub value: EspObservationValue,
687}
688
689#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
690#[serde(rename_all = "camelCase")]
691pub struct EspJsonObservation {
692 pub context: EspObservationContext,
693 pub document_type: String,
694 pub json_pointer: String,
695 pub value: EspObservationValue,
696}
697
698#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
699#[serde(rename_all = "camelCase")]
700pub struct EspEventLogObservation {
701 pub context: EspObservationContext,
702 pub channel: String,
703 pub event_id: u32,
704 pub record_id: Option<u64>,
705 pub named_data: Vec<EspNamedValue>,
706 pub message: Option<String>,
707}
708
709#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
710#[serde(rename_all = "camelCase")]
711pub struct EspImeObservation {
712 pub context: EspObservationContext,
713 pub component: Option<String>,
714 pub message: String,
715 pub app_id: Option<String>,
716 pub status: Option<EspStatus>,
717}
718
719#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
720#[serde(rename_all = "camelCase")]
721pub struct EspDeploymentLogObservation {
722 pub context: EspObservationContext,
723 pub component: Option<String>,
724 pub message: String,
725 pub product_code: Option<String>,
726 pub log_path: Option<String>,
727 pub status: Option<EspStatus>,
728}
729
730#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
731#[serde(rename_all = "camelCase")]
732pub struct EspProcessObservation {
733 pub context: EspObservationContext,
734 pub pid: u32,
735 pub process_start_time: EspTimestamp,
736 pub parent_pid: Option<u32>,
737 pub executable_name: String,
738 pub sanitized_command_line: Option<String>,
739 pub referenced_log_path: Option<String>,
740 pub app_id: Option<String>,
741 pub product_code: Option<String>,
742}
743
744#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
745#[serde(rename_all = "camelCase")]
746pub struct EspSystemObservation {
747 pub context: EspObservationContext,
748 pub fact: EspSystemFact,
749}
750
751#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
752#[serde(rename_all = "camelCase")]
753pub struct EspDeliveryOptimizationObservation {
754 pub context: EspObservationContext,
755 pub kind: EspDeliveryOptimizationEventKind,
756 pub content_id: Option<String>,
757 pub app_id: Option<String>,
758 pub http_bytes: Option<u64>,
759 pub lan_bytes: Option<u64>,
760 pub cache_host_bytes: Option<u64>,
761}
762
763#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
764#[serde(rename_all = "camelCase")]
765pub struct EspGraphObservation {
766 pub context: EspObservationContext,
767 pub section: EspGraphObservationSection,
768 pub api_version: GraphApiVersion,
769 pub record_id: String,
770 pub display_name: Option<String>,
771 pub status: Option<EspStatus>,
772}
773
774#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
775#[serde(rename_all = "camelCase")]
776pub struct EspInstallerCorrelation {
777 pub correlation_id: String,
778 pub workload_id: Option<String>,
779 pub confidence: EspCorrelationConfidence,
780 pub reason: String,
781 pub candidate_workload_ids: Vec<String>,
782 pub process_observations: Vec<EspProcessObservation>,
783 pub evidence: Vec<EspEvidenceRef>,
784}
785
786#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
787#[serde(rename_all = "camelCase")]
788pub struct EspDiagnosticsSnapshot {
789 pub schema_version: u32,
790 pub scenario: EspScenario,
791 pub phase: EspPhase,
792 pub generated_at_utc: String,
793 pub elevation: EspElevationState,
794 pub identity: EspIdentityEvidence,
795 pub profile: Option<EspProfileEvidence>,
796 pub enrollments: Vec<EspEnrollmentEvidence>,
797 pub sessions: Vec<EspSession>,
798 pub workloads: Vec<EspWorkload>,
799 pub installer_correlations: Vec<EspInstallerCorrelation>,
800 pub node_cache: Vec<EspNodeCacheEntry>,
801 pub registration_events: Vec<EspRegistrationEvent>,
802 pub delivery_optimization: Option<EspDeliveryOptimizationEvidence>,
803 pub hardware: Option<EspHardwareEvidence>,
804 pub activity: Vec<EspTimelineEntry>,
805 pub findings: Vec<EspDiagnosticFinding>,
806 pub coverage: Vec<EspArtifactCoverage>,
807 pub raw_evidence: Vec<EspRawEvidenceRecord>,
808 pub graph: Option<EspGraphOverlay>,
809}
810
811#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
812#[serde(rename_all = "camelCase")]
813pub struct GraphSectionError {
814 pub code: String,
815 pub message: String,
816 pub request_id: Option<String>,
817 pub blocked_by: Option<String>,
818 pub retry_after_seconds: Option<u64>,
819}
820
821#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
822#[serde(rename_all = "camelCase")]
823pub struct GraphSection<T> {
824 pub status: GraphSectionStatus,
825 pub required_scope: Option<String>,
826 pub api_version: GraphApiVersion,
827 pub data: Option<T>,
828 pub error: Option<GraphSectionError>,
829}
830
831#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
832#[serde(rename_all = "camelCase")]
833pub struct EspGraphManagedDevice {
834 pub managed_device_id: String,
835 pub entra_device_id: Option<String>,
836 pub serial_number: Option<EspClassifiedString>,
837 pub device_name: Option<String>,
838 pub user_id: Option<String>,
839 pub user_principal_name: Option<EspClassifiedString>,
840 pub tenant_id: Option<EspClassifiedString>,
841 pub evidence: Vec<EspEvidenceRef>,
842}
843
844#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
845#[serde(rename_all = "camelCase")]
846pub struct EspGraphDeviceMatch {
847 pub selected: Option<EspGraphManagedDevice>,
848 pub candidates: Vec<EspGraphManagedDevice>,
849 pub match_basis: Option<String>,
850 pub confidence: EspCorrelationConfidence,
851 pub evidence: Vec<EspEvidenceRef>,
852}
853
854#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
855#[serde(rename_all = "camelCase")]
856pub struct EspGraphAutopilotIdentity {
857 pub autopilot_device_id: String,
858 pub entra_device_id: Option<String>,
859 pub serial_number: Option<EspClassifiedString>,
860 pub deployment_profile_id: Option<String>,
861 pub group_tag: Option<String>,
862 pub evidence: Vec<EspEvidenceRef>,
863}
864
865#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
866#[serde(rename_all = "camelCase")]
867pub struct EspGraphDeploymentProfile {
868 pub profile_id: String,
869 pub display_name: Option<String>,
870 pub join_mode: Option<EspJoinMode>,
871 pub selected_mobile_app_ids: Vec<String>,
872 pub evidence: Vec<EspEvidenceRef>,
873}
874
875#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
876#[serde(rename_all = "camelCase")]
877pub struct EspGraphAssignment {
878 pub assignment_id: String,
879 pub target_id: Option<String>,
880 pub filter_id: Option<String>,
881 pub intent: EspGraphAssignmentIntent,
882 pub target_kind: EspGraphTargetKind,
883 pub targeting: EspGraphTargeting,
884 pub evidence: Vec<EspEvidenceRef>,
885}
886
887#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
888#[serde(rename_all = "camelCase")]
889pub struct EspGraphPolicyStatusDetail {
890 pub status_detail_id: String,
891 pub related_object_id: Option<String>,
892 pub display_name: Option<String>,
893 pub kind: EspGraphPolicyStatusDetailKind,
894 pub status: EspStatus,
895 #[serde(default)]
896 pub tracked_on_enrollment_status: Option<bool>,
897 pub correlation_confidence: EspCorrelationConfidence,
898 pub evidence: Vec<EspEvidenceRef>,
899}
900
901#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
902#[serde(rename_all = "camelCase")]
903pub struct EspGraphAutopilotEvent {
904 pub event_id: String,
905 pub managed_device_id: Option<String>,
906 #[serde(default)]
907 pub enrollment_configuration_id: Option<String>,
908 pub event_time: Option<EspTimestamp>,
909 pub deployment_state: EspStatus,
910 pub policy_status_details: Vec<EspGraphPolicyStatusDetail>,
911 pub evidence: Vec<EspEvidenceRef>,
912}
913
914#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
915#[serde(rename_all = "camelCase")]
916pub struct EspGraphEnrollmentConfiguration {
917 pub configuration_id: String,
918 pub display_name: Option<String>,
919 #[serde(default)]
920 pub show_installation_progress: Option<bool>,
921 pub device_esp_enabled: Option<bool>,
922 pub user_esp_enabled: Option<bool>,
923 #[serde(default)]
924 pub disable_user_status_tracking_after_first_user: Option<bool>,
925 pub timeout_minutes: Option<u64>,
926 pub selected_mobile_app_ids: Vec<String>,
927 pub assignments: Vec<EspGraphAssignment>,
928 pub evidence: Vec<EspEvidenceRef>,
929}
930
931#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
932#[serde(rename_all = "camelCase")]
933pub struct EspGraphAppRecord {
934 pub app_id: String,
935 pub display_name: Option<String>,
936 pub tracked_on_enrollment_status: Option<bool>,
937 pub status: Option<EspStatus>,
938 pub intent_state: GraphSection<EspStatus>,
939 pub assignments: Vec<EspGraphAssignment>,
940 pub evidence: Vec<EspEvidenceRef>,
941}
942
943#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
944#[serde(rename_all = "camelCase")]
945pub struct EspGraphPolicyRecord {
946 pub policy_id: String,
947 pub display_name: Option<String>,
948 pub kind: EspGraphPolicyKind,
949 pub status: Option<EspStatus>,
950 pub assignments: Vec<EspGraphAssignment>,
951 pub evidence: Vec<EspEvidenceRef>,
952}
953
954#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
955#[serde(rename_all = "camelCase")]
956pub struct EspGraphScriptRecord {
957 pub script_id: String,
958 pub display_name: Option<String>,
959 pub kind: EspGraphScriptKind,
960 pub status: Option<EspStatus>,
961 pub assignments: Vec<EspGraphAssignment>,
962 pub evidence: Vec<EspEvidenceRef>,
963}
964
965#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
966#[serde(rename_all = "camelCase")]
967pub struct EspGraphOverlay {
968 pub request_id: String,
969 pub requested_at_utc: String,
970 pub device_match: GraphSection<EspGraphDeviceMatch>,
971 pub autopilot_identity: GraphSection<EspGraphAutopilotIdentity>,
972 pub deployment_profile: GraphSection<EspGraphDeploymentProfile>,
973 pub intended_deployment_profile: GraphSection<EspGraphDeploymentProfile>,
974 pub profile_assignments: GraphSection<Vec<EspGraphAssignment>>,
975 pub autopilot_events: GraphSection<Vec<EspGraphAutopilotEvent>>,
976 pub enrollment_configuration: GraphSection<EspGraphEnrollmentConfiguration>,
977 pub apps: GraphSection<Vec<EspGraphAppRecord>>,
978 pub policies: GraphSection<Vec<EspGraphPolicyRecord>>,
979 pub scripts: GraphSection<Vec<EspGraphScriptRecord>>,
980}