Skip to main content

canic_host/deployment_truth/
model.rs

1use serde::{Deserialize, Serialize};
2
3///
4/// DeploymentPlanV1
5///
6#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
7pub struct DeploymentPlanV1 {
8    pub schema_version: u32,
9    pub plan_id: String,
10    pub deployment_identity: DeploymentIdentityV1,
11    pub trust_domain: TrustDomainV1,
12    pub fleet_template: String,
13    pub runtime_variant: String,
14    pub authority_profile: AuthorityProfileV1,
15    pub role_artifacts: Vec<RoleArtifactV1>,
16    pub expected_canisters: Vec<ExpectedCanisterV1>,
17    pub expected_pool: Vec<ExpectedPoolCanisterV1>,
18    pub expected_verifier_readiness: VerifierReadinessExpectationV1,
19    pub unresolved_assumptions: Vec<DeploymentAssumptionV1>,
20}
21
22///
23/// DeploymentInventoryV1
24///
25#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
26pub struct DeploymentInventoryV1 {
27    pub schema_version: u32,
28    pub inventory_id: String,
29    pub observed_at: String,
30    pub observed_identity: Option<DeploymentIdentityV1>,
31    pub local_config: LocalDeploymentConfigV1,
32    pub observed_canisters: Vec<ObservedCanisterV1>,
33    pub observed_pool: Vec<ObservedPoolCanisterV1>,
34    pub observed_artifacts: Vec<ObservedArtifactV1>,
35    pub observed_verifier_readiness: VerifierReadinessObservationV1,
36    pub unresolved_observations: Vec<DeploymentObservationGapV1>,
37}
38
39///
40/// DeploymentReceiptV1
41///
42#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
43pub struct DeploymentReceiptV1 {
44    pub schema_version: u32,
45    pub operation_id: String,
46    pub plan_id: String,
47    pub execution_context: Option<DeploymentExecutionContextV1>,
48    pub operation_status: DeploymentExecutionStatusV1,
49    pub started_at: String,
50    pub finished_at: Option<String>,
51    pub operator_principal: Option<String>,
52    pub root_principal: Option<String>,
53    pub previous_observed_deployment_epoch: Option<u64>,
54    pub phase_receipts: Vec<PhaseReceiptV1>,
55    pub role_phase_receipts: Vec<RolePhaseReceiptV1>,
56    pub final_inventory_id: Option<String>,
57    pub command_result: DeploymentCommandResultV1,
58}
59
60///
61/// DeploymentExecutionContextV1
62///
63#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
64pub struct DeploymentExecutionContextV1 {
65    pub workspace_root: Option<String>,
66    pub icp_root: Option<String>,
67    pub artifact_roots: Vec<String>,
68    pub backend: DeploymentExecutorBackendV1,
69    pub backend_capabilities: Vec<DeploymentExecutorCapabilityV1>,
70}
71
72///
73/// DeploymentExecutionPreflightV1
74///
75#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
76pub struct DeploymentExecutionPreflightV1 {
77    pub schema_version: u32,
78    pub plan_id: String,
79    pub safety_report_id: String,
80    pub authority_plan_id: String,
81    pub backend: DeploymentExecutorBackendV1,
82    pub status: DeploymentExecutionPreflightStatusV1,
83    pub planned_phases: Vec<String>,
84    pub required_capabilities: Vec<DeploymentExecutorCapabilityV1>,
85    pub missing_capabilities: Vec<DeploymentExecutorCapabilityV1>,
86    pub blockers: Vec<SafetyFindingV1>,
87}
88
89///
90/// DeploymentExecutionPreflightStatusV1
91///
92#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
93pub enum DeploymentExecutionPreflightStatusV1 {
94    Ready,
95    Blocked,
96}
97
98///
99/// DeploymentExecutorBackendV1
100///
101#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
102pub enum DeploymentExecutorBackendV1 {
103    CurrentCli,
104    PocketIc,
105    DirectAgent,
106    Other { name: String },
107}
108
109///
110/// DeploymentExecutorCapabilityV1
111///
112#[derive(Clone, Copy, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Serialize)]
113pub enum DeploymentExecutorCapabilityV1 {
114    CreateCanister,
115    CanisterStatus,
116    UpdateSettings,
117    InstallCode,
118    Call,
119    Query,
120    StageArtifact,
121}
122
123///
124/// ArtifactTransportV1
125///
126#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
127pub enum ArtifactTransportV1 {
128    LocalCli,
129    WasmStore,
130    DirectAgent,
131}
132
133///
134/// StagingReceiptV1
135///
136#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
137pub struct StagingReceiptV1 {
138    pub schema_version: u32,
139    pub role: String,
140    pub artifact_identity: String,
141    pub transport: ArtifactTransportV1,
142    pub wasm_store_locator: Option<String>,
143    pub prepared_chunk_hashes: Vec<String>,
144    pub published_chunk_count: usize,
145    pub verified_postcondition: VerifiedPostconditionV1,
146}
147
148///
149/// RoleArtifactSourceV1
150///
151#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
152pub struct RoleArtifactSourceV1 {
153    pub role: String,
154    pub kind: RoleArtifactSourceKindV1,
155    pub locator: Option<String>,
156    pub previous_receipt_kind: Option<PreviousArtifactReceiptKindV1>,
157    pub expected_wasm_sha256: Option<String>,
158    pub expected_wasm_gz_sha256: Option<String>,
159    pub expected_candid_sha256: Option<String>,
160    pub expected_canonical_embedded_config_sha256: Option<String>,
161}
162
163///
164/// RolePromotionInputV1
165///
166#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
167pub struct RolePromotionInputV1 {
168    pub role: String,
169    pub promotion_level: PromotionArtifactLevelV1,
170    pub source: RoleArtifactSourceV1,
171    pub require_byte_identical_wasm: bool,
172    pub require_target_embedded_config: bool,
173    pub target_store_has_artifact: Option<bool>,
174}
175
176///
177/// PromotionArtifactLevelV1
178///
179#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
180pub enum PromotionArtifactLevelV1 {
181    SealedWasm,
182    SourceBuild,
183}
184
185///
186/// PromotionReadinessV1
187///
188#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
189pub struct PromotionReadinessV1 {
190    pub schema_version: u32,
191    pub readiness_id: String,
192    pub target_plan_id: String,
193    pub status: PromotionReadinessStatusV1,
194    pub roles: Vec<RolePromotionReadinessV1>,
195    pub blockers: Vec<SafetyFindingV1>,
196    pub warnings: Vec<SafetyFindingV1>,
197}
198
199///
200/// PromotionPlanTransformV1
201///
202#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
203pub struct PromotionPlanTransformV1 {
204    pub schema_version: u32,
205    pub transform_id: String,
206    pub target_plan_id: String,
207    pub promoted_plan_id: String,
208    pub promoted_plan: DeploymentPlanV1,
209    pub roles: Vec<RolePromotionPlanTransformV1>,
210}
211
212///
213/// PromotionPlanTransformEvidenceV1
214///
215#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
216pub struct PromotionPlanTransformEvidenceV1 {
217    pub schema_version: u32,
218    pub evidence_id: String,
219    pub generated_at: String,
220    pub transform: PromotionPlanTransformV1,
221}
222
223///
224/// RolePromotionPlanTransformV1
225///
226#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
227pub struct RolePromotionPlanTransformV1 {
228    pub role: String,
229    pub promotion_level: PromotionArtifactLevelV1,
230    pub source_kind: RoleArtifactSourceKindV1,
231    pub source_locator: Option<String>,
232    pub artifact_source_before: ArtifactSourceV1,
233    pub artifact_source_after: ArtifactSourceV1,
234    pub wasm_sha256_before: Option<String>,
235    pub wasm_sha256_after: Option<String>,
236    pub wasm_gz_sha256_before: Option<String>,
237    pub wasm_gz_sha256_after: Option<String>,
238    pub candid_sha256_before: Option<String>,
239    pub candid_sha256_after: Option<String>,
240    pub canonical_embedded_config_sha256_before: Option<String>,
241    pub canonical_embedded_config_sha256_after: Option<String>,
242    pub artifact_identity_changed: bool,
243    pub embedded_config_changed: bool,
244    pub target_materialization_preserved: bool,
245}
246
247///
248/// PromotionReadinessStatusV1
249///
250#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
251pub enum PromotionReadinessStatusV1 {
252    Ready,
253    Blocked,
254}
255
256///
257/// RolePromotionReadinessV1
258///
259#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
260pub struct RolePromotionReadinessV1 {
261    pub role: String,
262    pub promotion_level: PromotionArtifactLevelV1,
263    pub source_kind: RoleArtifactSourceKindV1,
264    pub source_locator: Option<String>,
265    pub source_wasm_sha256: Option<String>,
266    pub source_wasm_gz_sha256: Option<String>,
267    pub target_wasm_sha256: Option<String>,
268    pub target_wasm_gz_sha256: Option<String>,
269    pub source_canonical_embedded_config_sha256: Option<String>,
270    pub target_canonical_embedded_config_sha256: Option<String>,
271    pub byte_identical_wasm: Option<bool>,
272    pub embedded_config_identical: Option<bool>,
273    pub target_store_has_artifact: Option<bool>,
274    pub restage_required: bool,
275}
276
277///
278/// RoleArtifactSourceKindV1
279///
280#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
281pub enum RoleArtifactSourceKindV1 {
282    WorkspacePackage,
283    PublishedPackage,
284    LocalWasm,
285    LocalWasmGz,
286    PreviousReceiptArtifact,
287    CanonicalWasmStoreDefault,
288}
289
290///
291/// PreviousArtifactReceiptKindV1
292///
293#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
294pub enum PreviousArtifactReceiptKindV1 {
295    DeploymentReceipt,
296    StagingReceipt,
297}
298
299///
300/// AuthorityReceiptV1
301///
302#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
303pub struct AuthorityReceiptV1 {
304    pub schema_version: u32,
305    pub operation_id: String,
306    pub check_id: Option<String>,
307    pub reconciliation_plan_id: String,
308    pub authority_report_id: String,
309    pub inventory_id: String,
310    pub authority_profile_hash: Option<String>,
311    pub operation_status: DeploymentExecutionStatusV1,
312    pub started_at: String,
313    pub finished_at: Option<String>,
314    pub attempted_actions: Vec<AuthorityAttemptedActionV1>,
315    pub verified_controller_observations: Vec<AuthorityControllerObservationV1>,
316    pub hard_failures: Vec<SafetyFindingV1>,
317    pub unresolved_observation_gaps: Vec<DeploymentObservationGapV1>,
318    pub unresolved_external_actions: Vec<AuthorityExternalActionV1>,
319    pub command_result: DeploymentCommandResultV1,
320}
321
322///
323/// AuthorityDryRunEvidenceV1
324///
325#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
326pub struct AuthorityDryRunEvidenceV1 {
327    pub schema_version: u32,
328    pub evidence_id: String,
329    pub check_id: String,
330    pub generated_at: String,
331    pub reconciliation_plan: AuthorityReconciliationPlanV1,
332    pub authority_report: AuthorityReportV1,
333    pub authority_receipt: AuthorityReceiptV1,
334}
335
336///
337/// AuthorityAttemptedActionV1
338///
339#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
340pub struct AuthorityAttemptedActionV1 {
341    pub subject: String,
342    pub canister_id: Option<String>,
343    pub role: Option<String>,
344    pub action: AuthorityActionV1,
345    pub result: RolePhaseResultV1,
346    pub error: Option<String>,
347}
348
349///
350/// AuthorityControllerObservationV1
351///
352#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
353pub struct AuthorityControllerObservationV1 {
354    pub subject: String,
355    pub canister_id: Option<String>,
356    pub role: Option<String>,
357    pub state: AuthorityReconciliationStateV1,
358    pub action: AuthorityActionV1,
359    pub observed_controllers: Vec<String>,
360    pub desired_controllers: Vec<String>,
361    pub controller_delta: AuthorityControllerDeltaV1,
362}
363
364///
365/// RoleArtifactManifestV1
366///
367#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
368pub struct RoleArtifactManifestV1 {
369    pub schema_version: u32,
370    pub manifest_id: String,
371    pub network: String,
372    pub artifact_root: Option<String>,
373    pub role_artifacts: Vec<RoleArtifactV1>,
374    pub unresolved_artifacts: Vec<DeploymentObservationGapV1>,
375}
376
377///
378/// DeploymentDiffV1
379///
380#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
381pub struct DeploymentDiffV1 {
382    pub schema_version: u32,
383    pub plan_identity: DeploymentIdentityV1,
384    pub observed_identity: Option<DeploymentIdentityV1>,
385    pub artifact_diff: Vec<DiffItemV1>,
386    pub controller_diff: Vec<DiffItemV1>,
387    pub pool_diff: Vec<DiffItemV1>,
388    pub embedded_config_diff: Vec<DiffItemV1>,
389    pub module_hash_diff: Vec<DiffItemV1>,
390    pub verifier_readiness_diff: Vec<DiffItemV1>,
391    pub resume_safety: ResumeSafetyV1,
392    pub hard_failures: Vec<SafetyFindingV1>,
393    pub warnings: Vec<SafetyFindingV1>,
394    pub resumable_phases: Vec<String>,
395}
396
397///
398/// SafetyReportV1
399///
400#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
401pub struct SafetyReportV1 {
402    pub schema_version: u32,
403    pub report_id: String,
404    pub diff_id: Option<String>,
405    pub status: SafetyStatusV1,
406    pub summary: String,
407    pub hard_failures: Vec<SafetyFindingV1>,
408    pub warnings: Vec<SafetyFindingV1>,
409    pub next_actions: Vec<String>,
410}
411
412///
413/// DeploymentCheckV1
414///
415#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
416pub struct DeploymentCheckV1 {
417    pub schema_version: u32,
418    pub check_id: String,
419    pub plan: DeploymentPlanV1,
420    pub inventory: DeploymentInventoryV1,
421    pub diff: DeploymentDiffV1,
422    pub report: SafetyReportV1,
423}
424
425///
426/// AuthorityReconciliationPlanV1
427///
428#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
429pub struct AuthorityReconciliationPlanV1 {
430    pub schema_version: u32,
431    pub plan_id: String,
432    pub inventory_id: String,
433    pub authority_profile_hash: Option<String>,
434    pub canister_actions: Vec<CanisterAuthorityActionV1>,
435    pub automatic_actions: Vec<AuthorityAutomaticActionV1>,
436    pub hard_failures: Vec<SafetyFindingV1>,
437    pub external_actions_required: Vec<AuthorityExternalActionV1>,
438}
439
440///
441/// AuthorityAutomaticActionV1
442///
443#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
444pub struct AuthorityAutomaticActionV1 {
445    pub subject: String,
446    pub canister_id: String,
447    pub role: Option<String>,
448    pub action: AuthorityActionV1,
449    pub observed_controllers: Vec<String>,
450    pub desired_controllers: Vec<String>,
451    pub controller_delta: AuthorityControllerDeltaV1,
452    pub reason: String,
453}
454
455///
456/// AuthorityControllerDeltaV1
457///
458#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
459pub struct AuthorityControllerDeltaV1 {
460    pub add_controllers: Vec<String>,
461    pub remove_controllers: Vec<String>,
462}
463
464///
465/// AuthorityReportV1
466///
467#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
468pub struct AuthorityReportV1 {
469    pub schema_version: u32,
470    pub report_id: String,
471    pub check_id: Option<String>,
472    pub reconciliation_plan_id: String,
473    pub inventory_id: String,
474    pub authority_profile_hash: Option<String>,
475    pub status: SafetyStatusV1,
476    pub summary: String,
477    pub counts: AuthorityReportCountsV1,
478    pub apply_readiness: AuthorityApplyReadinessV1,
479    pub action_counts: Vec<AuthorityActionCountV1>,
480    pub control_class_counts: Vec<AuthorityControlClassCountV1>,
481    pub observation_gaps: Vec<DeploymentObservationGapV1>,
482    pub automatic_actions: Vec<AuthorityAutomaticActionV1>,
483    pub hard_failures: Vec<SafetyFindingV1>,
484    pub external_actions_required: Vec<AuthorityExternalActionV1>,
485    pub next_actions: Vec<String>,
486}
487
488///
489/// AuthorityApplyReadinessV1
490///
491#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
492pub struct AuthorityApplyReadinessV1 {
493    pub can_apply_automatically: bool,
494    pub automatic_action_count: usize,
495    pub blockers: Vec<AuthorityApplyBlockerV1>,
496}
497
498///
499/// AuthorityApplyBlockerV1
500///
501#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
502pub enum AuthorityApplyBlockerV1 {
503    UnsafeBlocked,
504    HardFailures,
505    ObservationGaps,
506    ExternalActions,
507}
508
509///
510/// AuthorityActionCountV1
511///
512#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
513pub struct AuthorityActionCountV1 {
514    pub action: AuthorityActionV1,
515    pub count: usize,
516}
517
518///
519/// AuthorityControlClassCountV1
520///
521#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
522pub struct AuthorityControlClassCountV1 {
523    pub control_class: CanisterControlClassV1,
524    pub count: usize,
525}
526
527///
528/// AuthorityReportCountsV1
529///
530#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
531pub struct AuthorityReportCountsV1 {
532    pub already_correct: usize,
533    pub can_apply_automatically: usize,
534    pub requires_external_action: usize,
535    pub unsafe_blocked: usize,
536    pub unknown: usize,
537    pub hard_failures: usize,
538}
539
540///
541/// CanisterAuthorityActionV1
542///
543#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
544pub struct CanisterAuthorityActionV1 {
545    pub canister_id: Option<String>,
546    pub role: Option<String>,
547    pub control_classification: CanisterControlClassV1,
548    pub observed_controllers: Vec<String>,
549    pub desired_controllers: Vec<String>,
550    pub controller_delta: AuthorityControllerDeltaV1,
551    pub action: AuthorityActionV1,
552    pub state: AuthorityReconciliationStateV1,
553    pub can_apply: bool,
554    pub reason: String,
555}
556
557///
558/// AuthorityExternalActionV1
559///
560#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
561pub struct AuthorityExternalActionV1 {
562    pub subject: String,
563    pub canister_id: Option<String>,
564    pub role: Option<String>,
565    pub control_classification: CanisterControlClassV1,
566    pub state: AuthorityReconciliationStateV1,
567    pub action: AuthorityActionV1,
568    pub observed_controllers: Vec<String>,
569    pub desired_controllers: Vec<String>,
570    pub controller_delta: AuthorityControllerDeltaV1,
571    pub reason: String,
572}
573
574///
575/// AuthorityActionV1
576///
577#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
578pub enum AuthorityActionV1 {
579    None,
580    AddControllers,
581    RemoveControllers,
582    ReplaceControllerSet,
583    RequiresExternalController,
584    RequiresDestructiveImportConfirmation,
585    ObserveOnly,
586    AdoptPlanAvailable,
587    BlockedByPolicy,
588    UnknownObservation,
589}
590
591///
592/// AuthorityReconciliationStateV1
593///
594#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
595pub enum AuthorityReconciliationStateV1 {
596    AlreadyCorrect,
597    CanApplyAutomatically,
598    RequiresExternalAction,
599    UnsafeBlocked,
600    Unknown,
601}
602
603///
604/// DeploymentIdentityV1
605///
606#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
607pub struct DeploymentIdentityV1 {
608    pub deployment_name: String,
609    pub network: String,
610    pub root_principal: Option<String>,
611    pub authority_profile_hash: Option<String>,
612    pub role_topology_hash: Option<String>,
613    pub deployment_manifest_digest: Option<String>,
614    pub canonical_runtime_config_digest: Option<String>,
615    pub role_embedded_config_set_digest: Option<String>,
616    pub artifact_set_digest: Option<String>,
617    pub pool_identity_set_digest: Option<String>,
618    pub canic_version: Option<String>,
619    pub ic_memory_version: Option<String>,
620}
621
622///
623/// TrustDomainV1
624///
625#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
626pub struct TrustDomainV1 {
627    pub root_trust_anchor: Option<String>,
628    pub migration_from: Option<String>,
629}
630
631///
632/// AuthorityProfileV1
633///
634#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
635pub struct AuthorityProfileV1 {
636    pub profile_id: String,
637    pub expected_controllers: Vec<String>,
638    pub staging_controllers: Vec<String>,
639    pub emergency_controllers: Vec<String>,
640}
641
642///
643/// RoleArtifactV1
644///
645#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
646pub struct RoleArtifactV1 {
647    pub role: String,
648    pub source: ArtifactSourceV1,
649    pub build_profile: String,
650    pub wasm_path: Option<String>,
651    pub wasm_gz_path: Option<String>,
652    pub wasm_gz_size_bytes: Option<u64>,
653    pub wasm_sha256: Option<String>,
654    pub wasm_gz_sha256: Option<String>,
655    pub wasm_gz_sha256_source: Option<ArtifactDigestSourceV1>,
656    pub observed_wasm_gz_file_sha256: Option<String>,
657    pub observed_wasm_gz_file_sha256_source: Option<ArtifactDigestSourceV1>,
658    pub installed_module_hash: Option<String>,
659    pub candid_path: Option<String>,
660    pub candid_sha256: Option<String>,
661    pub raw_config_sha256: Option<String>,
662    pub canonical_embedded_config_sha256: Option<String>,
663    pub embedded_topology_sha256: Option<String>,
664    pub builder_version: Option<String>,
665    pub rust_toolchain: Option<String>,
666    pub package_version: Option<String>,
667}
668
669///
670/// ArtifactDigestSourceV1
671///
672#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
673pub enum ArtifactDigestSourceV1 {
674    ReleaseSetManifest,
675    ObservedFileDigest,
676    InstalledModuleHash,
677}
678
679///
680/// ArtifactSourceV1
681///
682#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
683pub enum ArtifactSourceV1 {
684    LocalBuild,
685    ReleaseSet,
686    WasmStore,
687    External,
688    Unknown,
689}
690
691///
692/// ExpectedCanisterV1
693///
694#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
695pub struct ExpectedCanisterV1 {
696    pub role: String,
697    pub canister_id: Option<String>,
698    pub control_class: CanisterControlClassV1,
699}
700
701///
702/// ObservedCanisterV1
703///
704#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
705pub struct ObservedCanisterV1 {
706    pub canister_id: String,
707    pub role: Option<String>,
708    pub control_class: CanisterControlClassV1,
709    pub controllers: Vec<String>,
710    pub module_hash: Option<String>,
711    pub status: Option<String>,
712    pub root_trust_anchor: Option<String>,
713    pub canonical_embedded_config_digest: Option<String>,
714    pub role_assignment_source: Option<String>,
715}
716
717///
718/// CanisterControlClassV1
719///
720#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
721pub enum CanisterControlClassV1 {
722    DeploymentControlled,
723    CanicManagedPool,
724    ExternallyImported,
725    JointlyControlled,
726    UserControlled,
727    UnknownUnsafe,
728}
729
730///
731/// ExpectedPoolCanisterV1
732///
733#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
734pub struct ExpectedPoolCanisterV1 {
735    pub pool: String,
736    pub canister_id: Option<String>,
737    pub role: Option<String>,
738}
739
740///
741/// ObservedPoolCanisterV1
742///
743#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
744pub struct ObservedPoolCanisterV1 {
745    pub pool: String,
746    pub canister_id: String,
747    pub role: Option<String>,
748    pub control_class: CanisterControlClassV1,
749}
750
751///
752/// LocalDeploymentConfigV1
753///
754#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
755pub struct LocalDeploymentConfigV1 {
756    pub config_path: Option<String>,
757    pub raw_config_sha256: Option<String>,
758    pub canonical_embedded_config_sha256: Option<String>,
759}
760
761///
762/// ObservedArtifactV1
763///
764#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
765pub struct ObservedArtifactV1 {
766    pub role: String,
767    pub artifact_path: String,
768    pub file_sha256: Option<String>,
769    pub file_sha256_source: Option<ArtifactDigestSourceV1>,
770    pub payload_sha256: Option<String>,
771    pub payload_size_bytes: Option<u64>,
772    pub source: ArtifactSourceV1,
773}
774
775///
776/// VerifierReadinessExpectationV1
777///
778#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
779pub struct VerifierReadinessExpectationV1 {
780    pub required: bool,
781    pub expected_role_epochs: Vec<RoleEpochExpectationV1>,
782}
783
784///
785/// VerifierReadinessObservationV1
786///
787#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
788pub struct VerifierReadinessObservationV1 {
789    pub status: ObservationStatusV1,
790    pub role_epochs: Vec<RoleEpochObservationV1>,
791}
792
793///
794/// RoleEpochExpectationV1
795///
796#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
797pub struct RoleEpochExpectationV1 {
798    pub role: String,
799    pub minimum_epoch: u64,
800}
801
802///
803/// RoleEpochObservationV1
804///
805#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
806pub struct RoleEpochObservationV1 {
807    pub role: String,
808    pub observed_epoch: Option<u64>,
809    pub status: ObservationStatusV1,
810}
811
812///
813/// DeploymentAssumptionV1
814///
815#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
816pub struct DeploymentAssumptionV1 {
817    pub key: String,
818    pub description: String,
819}
820
821///
822/// DeploymentObservationGapV1
823///
824#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
825pub struct DeploymentObservationGapV1 {
826    pub key: String,
827    pub description: String,
828}
829
830///
831/// PhaseReceiptV1
832///
833#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
834pub struct PhaseReceiptV1 {
835    pub phase: String,
836    pub started_at: String,
837    pub finished_at: Option<String>,
838    pub attempted_action: String,
839    pub verified_postcondition: VerifiedPostconditionV1,
840}
841
842///
843/// VerifiedPostconditionV1
844///
845#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
846pub struct VerifiedPostconditionV1 {
847    pub status: ObservationStatusV1,
848    pub evidence: Vec<String>,
849}
850
851///
852/// DeploymentExecutionStatusV1
853///
854#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
855pub enum DeploymentExecutionStatusV1 {
856    NotStarted,
857    InProgress,
858    FailedBeforeMutation,
859    PartiallyApplied,
860    FailedAfterMutation,
861    Complete,
862}
863
864///
865/// DeploymentCommandResultV1
866///
867#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
868pub enum DeploymentCommandResultV1 {
869    NotFinished,
870    Succeeded,
871    Failed { code: String, message: String },
872}
873
874///
875/// RolePhaseReceiptV1
876///
877#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
878pub struct RolePhaseReceiptV1 {
879    pub role: String,
880    pub phase: String,
881    pub result: RolePhaseResultV1,
882    pub previous_module_hash: Option<String>,
883    pub target_module_hash: Option<String>,
884    pub observed_module_hash_after: Option<String>,
885    pub artifact_digest: Option<String>,
886    pub canonical_embedded_config_sha256: Option<String>,
887    pub error: Option<String>,
888}
889
890///
891/// RolePhaseResultV1
892///
893#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
894pub enum RolePhaseResultV1 {
895    Applied,
896    Failed,
897    Skipped,
898    NotAttempted,
899    VerifiedAlreadyApplied,
900}
901
902///
903/// DiffItemV1
904///
905#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
906pub struct DiffItemV1 {
907    pub category: String,
908    pub subject: String,
909    pub expected: Option<String>,
910    pub observed: Option<String>,
911    pub severity: SafetySeverityV1,
912}
913
914///
915/// ResumeSafetyV1
916///
917#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
918pub struct ResumeSafetyV1 {
919    pub status: SafetyStatusV1,
920    pub reasons: Vec<String>,
921}
922
923///
924/// SafetyFindingV1
925///
926#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
927pub struct SafetyFindingV1 {
928    pub code: String,
929    pub message: String,
930    pub severity: SafetySeverityV1,
931    pub subject: Option<String>,
932}
933
934///
935/// SafetyStatusV1
936///
937#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
938pub enum SafetyStatusV1 {
939    NotEvaluated,
940    Safe,
941    Warning,
942    Blocked,
943}
944
945///
946/// SafetySeverityV1
947///
948#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
949pub enum SafetySeverityV1 {
950    Info,
951    Warning,
952    HardFailure,
953}
954
955///
956/// ObservationStatusV1
957///
958#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
959pub enum ObservationStatusV1 {
960    NotObserved,
961    Observed,
962    Missing,
963    Inconclusive,
964}