Skip to main content

cmtraceopen_parser/esp/
models.rs

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}