1use serde::{Deserialize, Serialize};
2
3#[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#[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#[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#[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#[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#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
93pub enum DeploymentExecutionPreflightStatusV1 {
94 Ready,
95 Blocked,
96}
97
98#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
102pub enum DeploymentExecutorBackendV1 {
103 CurrentCli,
104 PocketIc,
105 DirectAgent,
106 Other { name: String },
107}
108
109#[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#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
127pub enum ArtifactTransportV1 {
128 LocalCli,
129 WasmStore,
130 DirectAgent,
131}
132
133#[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#[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#[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#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
180pub enum PromotionArtifactLevelV1 {
181 SealedWasm,
182 SourceBuild,
183}
184
185#[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#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
203pub enum PromotionReadinessStatusV1 {
204 Ready,
205 Blocked,
206}
207
208#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
212pub struct RolePromotionReadinessV1 {
213 pub role: String,
214 pub promotion_level: PromotionArtifactLevelV1,
215 pub source_kind: RoleArtifactSourceKindV1,
216 pub source_locator: Option<String>,
217 pub source_wasm_sha256: Option<String>,
218 pub source_wasm_gz_sha256: Option<String>,
219 pub target_wasm_sha256: Option<String>,
220 pub target_wasm_gz_sha256: Option<String>,
221 pub source_canonical_embedded_config_sha256: Option<String>,
222 pub target_canonical_embedded_config_sha256: Option<String>,
223 pub byte_identical_wasm: Option<bool>,
224 pub embedded_config_identical: Option<bool>,
225 pub target_store_has_artifact: Option<bool>,
226 pub restage_required: bool,
227}
228
229#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
233pub enum RoleArtifactSourceKindV1 {
234 WorkspacePackage,
235 PublishedPackage,
236 LocalWasm,
237 LocalWasmGz,
238 PreviousReceiptArtifact,
239 CanonicalWasmStoreDefault,
240}
241
242#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
246pub enum PreviousArtifactReceiptKindV1 {
247 DeploymentReceipt,
248 StagingReceipt,
249}
250
251#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
255pub struct AuthorityReceiptV1 {
256 pub schema_version: u32,
257 pub operation_id: String,
258 pub check_id: Option<String>,
259 pub reconciliation_plan_id: String,
260 pub authority_report_id: String,
261 pub inventory_id: String,
262 pub authority_profile_hash: Option<String>,
263 pub operation_status: DeploymentExecutionStatusV1,
264 pub started_at: String,
265 pub finished_at: Option<String>,
266 pub attempted_actions: Vec<AuthorityAttemptedActionV1>,
267 pub verified_controller_observations: Vec<AuthorityControllerObservationV1>,
268 pub hard_failures: Vec<SafetyFindingV1>,
269 pub unresolved_observation_gaps: Vec<DeploymentObservationGapV1>,
270 pub unresolved_external_actions: Vec<AuthorityExternalActionV1>,
271 pub command_result: DeploymentCommandResultV1,
272}
273
274#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
278pub struct AuthorityDryRunEvidenceV1 {
279 pub schema_version: u32,
280 pub evidence_id: String,
281 pub check_id: String,
282 pub generated_at: String,
283 pub reconciliation_plan: AuthorityReconciliationPlanV1,
284 pub authority_report: AuthorityReportV1,
285 pub authority_receipt: AuthorityReceiptV1,
286}
287
288#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
292pub struct AuthorityAttemptedActionV1 {
293 pub subject: String,
294 pub canister_id: Option<String>,
295 pub role: Option<String>,
296 pub action: AuthorityActionV1,
297 pub result: RolePhaseResultV1,
298 pub error: Option<String>,
299}
300
301#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
305pub struct AuthorityControllerObservationV1 {
306 pub subject: String,
307 pub canister_id: Option<String>,
308 pub role: Option<String>,
309 pub state: AuthorityReconciliationStateV1,
310 pub action: AuthorityActionV1,
311 pub observed_controllers: Vec<String>,
312 pub desired_controllers: Vec<String>,
313 pub controller_delta: AuthorityControllerDeltaV1,
314}
315
316#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
320pub struct RoleArtifactManifestV1 {
321 pub schema_version: u32,
322 pub manifest_id: String,
323 pub network: String,
324 pub artifact_root: Option<String>,
325 pub role_artifacts: Vec<RoleArtifactV1>,
326 pub unresolved_artifacts: Vec<DeploymentObservationGapV1>,
327}
328
329#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
333pub struct DeploymentDiffV1 {
334 pub schema_version: u32,
335 pub plan_identity: DeploymentIdentityV1,
336 pub observed_identity: Option<DeploymentIdentityV1>,
337 pub artifact_diff: Vec<DiffItemV1>,
338 pub controller_diff: Vec<DiffItemV1>,
339 pub pool_diff: Vec<DiffItemV1>,
340 pub embedded_config_diff: Vec<DiffItemV1>,
341 pub module_hash_diff: Vec<DiffItemV1>,
342 pub verifier_readiness_diff: Vec<DiffItemV1>,
343 pub resume_safety: ResumeSafetyV1,
344 pub hard_failures: Vec<SafetyFindingV1>,
345 pub warnings: Vec<SafetyFindingV1>,
346 pub resumable_phases: Vec<String>,
347}
348
349#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
353pub struct SafetyReportV1 {
354 pub schema_version: u32,
355 pub report_id: String,
356 pub diff_id: Option<String>,
357 pub status: SafetyStatusV1,
358 pub summary: String,
359 pub hard_failures: Vec<SafetyFindingV1>,
360 pub warnings: Vec<SafetyFindingV1>,
361 pub next_actions: Vec<String>,
362}
363
364#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
368pub struct DeploymentCheckV1 {
369 pub schema_version: u32,
370 pub check_id: String,
371 pub plan: DeploymentPlanV1,
372 pub inventory: DeploymentInventoryV1,
373 pub diff: DeploymentDiffV1,
374 pub report: SafetyReportV1,
375}
376
377#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
381pub struct AuthorityReconciliationPlanV1 {
382 pub schema_version: u32,
383 pub plan_id: String,
384 pub inventory_id: String,
385 pub authority_profile_hash: Option<String>,
386 pub canister_actions: Vec<CanisterAuthorityActionV1>,
387 pub automatic_actions: Vec<AuthorityAutomaticActionV1>,
388 pub hard_failures: Vec<SafetyFindingV1>,
389 pub external_actions_required: Vec<AuthorityExternalActionV1>,
390}
391
392#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
396pub struct AuthorityAutomaticActionV1 {
397 pub subject: String,
398 pub canister_id: String,
399 pub role: Option<String>,
400 pub action: AuthorityActionV1,
401 pub observed_controllers: Vec<String>,
402 pub desired_controllers: Vec<String>,
403 pub controller_delta: AuthorityControllerDeltaV1,
404 pub reason: String,
405}
406
407#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
411pub struct AuthorityControllerDeltaV1 {
412 pub add_controllers: Vec<String>,
413 pub remove_controllers: Vec<String>,
414}
415
416#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
420pub struct AuthorityReportV1 {
421 pub schema_version: u32,
422 pub report_id: String,
423 pub check_id: Option<String>,
424 pub reconciliation_plan_id: String,
425 pub inventory_id: String,
426 pub authority_profile_hash: Option<String>,
427 pub status: SafetyStatusV1,
428 pub summary: String,
429 pub counts: AuthorityReportCountsV1,
430 pub apply_readiness: AuthorityApplyReadinessV1,
431 pub action_counts: Vec<AuthorityActionCountV1>,
432 pub control_class_counts: Vec<AuthorityControlClassCountV1>,
433 pub observation_gaps: Vec<DeploymentObservationGapV1>,
434 pub automatic_actions: Vec<AuthorityAutomaticActionV1>,
435 pub hard_failures: Vec<SafetyFindingV1>,
436 pub external_actions_required: Vec<AuthorityExternalActionV1>,
437 pub next_actions: Vec<String>,
438}
439
440#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
444pub struct AuthorityApplyReadinessV1 {
445 pub can_apply_automatically: bool,
446 pub automatic_action_count: usize,
447 pub blockers: Vec<AuthorityApplyBlockerV1>,
448}
449
450#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
454pub enum AuthorityApplyBlockerV1 {
455 UnsafeBlocked,
456 HardFailures,
457 ObservationGaps,
458 ExternalActions,
459}
460
461#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
465pub struct AuthorityActionCountV1 {
466 pub action: AuthorityActionV1,
467 pub count: usize,
468}
469
470#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
474pub struct AuthorityControlClassCountV1 {
475 pub control_class: CanisterControlClassV1,
476 pub count: usize,
477}
478
479#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
483pub struct AuthorityReportCountsV1 {
484 pub already_correct: usize,
485 pub can_apply_automatically: usize,
486 pub requires_external_action: usize,
487 pub unsafe_blocked: usize,
488 pub unknown: usize,
489 pub hard_failures: usize,
490}
491
492#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
496pub struct CanisterAuthorityActionV1 {
497 pub canister_id: Option<String>,
498 pub role: Option<String>,
499 pub control_classification: CanisterControlClassV1,
500 pub observed_controllers: Vec<String>,
501 pub desired_controllers: Vec<String>,
502 pub controller_delta: AuthorityControllerDeltaV1,
503 pub action: AuthorityActionV1,
504 pub state: AuthorityReconciliationStateV1,
505 pub can_apply: bool,
506 pub reason: String,
507}
508
509#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
513pub struct AuthorityExternalActionV1 {
514 pub subject: String,
515 pub canister_id: Option<String>,
516 pub role: Option<String>,
517 pub control_classification: CanisterControlClassV1,
518 pub state: AuthorityReconciliationStateV1,
519 pub action: AuthorityActionV1,
520 pub observed_controllers: Vec<String>,
521 pub desired_controllers: Vec<String>,
522 pub controller_delta: AuthorityControllerDeltaV1,
523 pub reason: String,
524}
525
526#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
530pub enum AuthorityActionV1 {
531 None,
532 AddControllers,
533 RemoveControllers,
534 ReplaceControllerSet,
535 RequiresExternalController,
536 RequiresDestructiveImportConfirmation,
537 ObserveOnly,
538 AdoptPlanAvailable,
539 BlockedByPolicy,
540 UnknownObservation,
541}
542
543#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
547pub enum AuthorityReconciliationStateV1 {
548 AlreadyCorrect,
549 CanApplyAutomatically,
550 RequiresExternalAction,
551 UnsafeBlocked,
552 Unknown,
553}
554
555#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
559pub struct DeploymentIdentityV1 {
560 pub deployment_name: String,
561 pub network: String,
562 pub root_principal: Option<String>,
563 pub authority_profile_hash: Option<String>,
564 pub role_topology_hash: Option<String>,
565 pub deployment_manifest_digest: Option<String>,
566 pub canonical_runtime_config_digest: Option<String>,
567 pub role_embedded_config_set_digest: Option<String>,
568 pub artifact_set_digest: Option<String>,
569 pub pool_identity_set_digest: Option<String>,
570 pub canic_version: Option<String>,
571 pub ic_memory_version: Option<String>,
572}
573
574#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
578pub struct TrustDomainV1 {
579 pub root_trust_anchor: Option<String>,
580 pub migration_from: Option<String>,
581}
582
583#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
587pub struct AuthorityProfileV1 {
588 pub profile_id: String,
589 pub expected_controllers: Vec<String>,
590 pub staging_controllers: Vec<String>,
591 pub emergency_controllers: Vec<String>,
592}
593
594#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
598pub struct RoleArtifactV1 {
599 pub role: String,
600 pub source: ArtifactSourceV1,
601 pub build_profile: String,
602 pub wasm_path: Option<String>,
603 pub wasm_gz_path: Option<String>,
604 pub wasm_gz_size_bytes: Option<u64>,
605 pub wasm_sha256: Option<String>,
606 pub wasm_gz_sha256: Option<String>,
607 pub wasm_gz_sha256_source: Option<ArtifactDigestSourceV1>,
608 pub observed_wasm_gz_file_sha256: Option<String>,
609 pub observed_wasm_gz_file_sha256_source: Option<ArtifactDigestSourceV1>,
610 pub installed_module_hash: Option<String>,
611 pub candid_path: Option<String>,
612 pub candid_sha256: Option<String>,
613 pub raw_config_sha256: Option<String>,
614 pub canonical_embedded_config_sha256: Option<String>,
615 pub embedded_topology_sha256: Option<String>,
616 pub builder_version: Option<String>,
617 pub rust_toolchain: Option<String>,
618 pub package_version: Option<String>,
619}
620
621#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
625pub enum ArtifactDigestSourceV1 {
626 ReleaseSetManifest,
627 ObservedFileDigest,
628 InstalledModuleHash,
629}
630
631#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
635pub enum ArtifactSourceV1 {
636 LocalBuild,
637 ReleaseSet,
638 WasmStore,
639 External,
640 Unknown,
641}
642
643#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
647pub struct ExpectedCanisterV1 {
648 pub role: String,
649 pub canister_id: Option<String>,
650 pub control_class: CanisterControlClassV1,
651}
652
653#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
657pub struct ObservedCanisterV1 {
658 pub canister_id: String,
659 pub role: Option<String>,
660 pub control_class: CanisterControlClassV1,
661 pub controllers: Vec<String>,
662 pub module_hash: Option<String>,
663 pub status: Option<String>,
664 pub root_trust_anchor: Option<String>,
665 pub canonical_embedded_config_digest: Option<String>,
666 pub role_assignment_source: Option<String>,
667}
668
669#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
673pub enum CanisterControlClassV1 {
674 DeploymentControlled,
675 CanicManagedPool,
676 ExternallyImported,
677 JointlyControlled,
678 UserControlled,
679 UnknownUnsafe,
680}
681
682#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
686pub struct ExpectedPoolCanisterV1 {
687 pub pool: String,
688 pub canister_id: Option<String>,
689 pub role: Option<String>,
690}
691
692#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
696pub struct ObservedPoolCanisterV1 {
697 pub pool: String,
698 pub canister_id: String,
699 pub role: Option<String>,
700 pub control_class: CanisterControlClassV1,
701}
702
703#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
707pub struct LocalDeploymentConfigV1 {
708 pub config_path: Option<String>,
709 pub raw_config_sha256: Option<String>,
710 pub canonical_embedded_config_sha256: Option<String>,
711}
712
713#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
717pub struct ObservedArtifactV1 {
718 pub role: String,
719 pub artifact_path: String,
720 pub file_sha256: Option<String>,
721 pub file_sha256_source: Option<ArtifactDigestSourceV1>,
722 pub payload_sha256: Option<String>,
723 pub payload_size_bytes: Option<u64>,
724 pub source: ArtifactSourceV1,
725}
726
727#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
731pub struct VerifierReadinessExpectationV1 {
732 pub required: bool,
733 pub expected_role_epochs: Vec<RoleEpochExpectationV1>,
734}
735
736#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
740pub struct VerifierReadinessObservationV1 {
741 pub status: ObservationStatusV1,
742 pub role_epochs: Vec<RoleEpochObservationV1>,
743}
744
745#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
749pub struct RoleEpochExpectationV1 {
750 pub role: String,
751 pub minimum_epoch: u64,
752}
753
754#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
758pub struct RoleEpochObservationV1 {
759 pub role: String,
760 pub observed_epoch: Option<u64>,
761 pub status: ObservationStatusV1,
762}
763
764#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
768pub struct DeploymentAssumptionV1 {
769 pub key: String,
770 pub description: String,
771}
772
773#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
777pub struct DeploymentObservationGapV1 {
778 pub key: String,
779 pub description: String,
780}
781
782#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
786pub struct PhaseReceiptV1 {
787 pub phase: String,
788 pub started_at: String,
789 pub finished_at: Option<String>,
790 pub attempted_action: String,
791 pub verified_postcondition: VerifiedPostconditionV1,
792}
793
794#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
798pub struct VerifiedPostconditionV1 {
799 pub status: ObservationStatusV1,
800 pub evidence: Vec<String>,
801}
802
803#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
807pub enum DeploymentExecutionStatusV1 {
808 NotStarted,
809 InProgress,
810 FailedBeforeMutation,
811 PartiallyApplied,
812 FailedAfterMutation,
813 Complete,
814}
815
816#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
820pub enum DeploymentCommandResultV1 {
821 NotFinished,
822 Succeeded,
823 Failed { code: String, message: String },
824}
825
826#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
830pub struct RolePhaseReceiptV1 {
831 pub role: String,
832 pub phase: String,
833 pub result: RolePhaseResultV1,
834 pub previous_module_hash: Option<String>,
835 pub target_module_hash: Option<String>,
836 pub observed_module_hash_after: Option<String>,
837 pub artifact_digest: Option<String>,
838 pub canonical_embedded_config_sha256: Option<String>,
839 pub error: Option<String>,
840}
841
842#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
846pub enum RolePhaseResultV1 {
847 Applied,
848 Failed,
849 Skipped,
850 NotAttempted,
851 VerifiedAlreadyApplied,
852}
853
854#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
858pub struct DiffItemV1 {
859 pub category: String,
860 pub subject: String,
861 pub expected: Option<String>,
862 pub observed: Option<String>,
863 pub severity: SafetySeverityV1,
864}
865
866#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
870pub struct ResumeSafetyV1 {
871 pub status: SafetyStatusV1,
872 pub reasons: Vec<String>,
873}
874
875#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
879pub struct SafetyFindingV1 {
880 pub code: String,
881 pub message: String,
882 pub severity: SafetySeverityV1,
883 pub subject: Option<String>,
884}
885
886#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
890pub enum SafetyStatusV1 {
891 NotEvaluated,
892 Safe,
893 Warning,
894 Blocked,
895}
896
897#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
901pub enum SafetySeverityV1 {
902 Info,
903 Warning,
904 HardFailure,
905}
906
907#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
911pub enum ObservationStatusV1 {
912 NotObserved,
913 Observed,
914 Missing,
915 Inconclusive,
916}