pub(all) suberror ModelError {
  EmptyField(String)
  SelfDependency(String)
  DuplicateAsset(String)
  MissingAsset(String)
  DuplicateDependency(String)
  DependencyCycle(String)
  InvalidImpactScore(String)
  InvalidDuration(String)
  InvalidBia(String)
  RecoveryResourceConflict(String)
  RecoveryTargetUnmet(String)
  PlaybookValidation(String)
  StepNotFound(String)
  StepBlocked(String)
  InvalidStepTransition(String)
  DrillValidation(String)
  InvalidDrillTransition(String)
  StorageValidation(String)
  ProjectNotFound(String)
  DuplicateAuditRecord(String)
  DuplicateUser(String)
  UserNotFound(String)
  AccessDenied(String)
}

pub(all) enum AssetRef {
  Service(ServiceId)
  Component(ComponentId)
}

pub(all) enum AuditAction {
  DrillStarted
  StepStarted
  StepApproved
  StepCompleted
  DrillFinished
}

pub(all) struct AuditEvent {
  sequence : Int
  timestamp_minutes : Int
  actor : String
  action : AuditAction
  step_id : String?
}

pub(all) struct AuditRecord {
  id : String
  project_id : String
  event : AuditEvent
}

pub(all) struct BusinessImpactAssessment {
  service_id : ServiceId
  impact_score : Int
  impact_level : ImpactLevel
  rto : TimeSpan
  rpo : TimeSpan
  max_tolerable_downtime : TimeSpan
}

pub(all) struct BusinessService {
  id : ServiceId
  name : String
  owner : String
}

pub(all) struct ComponentId {
  value : String
}

pub(all) struct ContinuityStorage {
  projects : Array[Project]
  audits : Array[AuditRecord]
}

pub(all) struct Dependency {
  dependent : AssetRef
  dependency : AssetRef
}

pub(all) enum DrillStatus {
  Planned
  Running
  Completed
}

pub(all) enum ImpactLevel {
  Low
  Medium
  High
  Critical
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ImpactPath {
  affected_asset : AssetRef
  path : Array[AssetRef]
}

pub(all) struct IncidentImpact {
  failed_asset : AssetRef
  affected : Array[AssetRef]
  paths : Array[ImpactPath]
}

pub(all) struct LocalAuthStore {
  users : Array[LocalUser]
}

pub(all) struct LocalUser {
  id : String
  username : String
  role : Role
  active : Bool
}

pub(all) enum Permission {
  ReadProjects
  ReadAudit
  RunDrills
  ApproveRecovery
  ManageUsers
}

pub(all) enum PlaybookStatus {
  Draft
  Active
  Completed
}

pub(all) struct Project {
  id : String
  name : String
  owner : String
}

pub(all) struct RecoveryConstraints {
  target_window : TimeSpan
  available_resources : Array[String]
}

pub(all) struct RecoveryDrill {
  id : String
  playbook : RecoveryPlaybook
  status : DrillStatus
  timeline : Array[AuditEvent]
}

pub(all) struct RecoveryItem {
  asset : AssetRef
  impact_level : ImpactLevel
  recovery_time : TimeSpan
  resource : String
}

pub(all) struct RecoveryPlan {
  ordered : Array[RecoveryItem]
  schedule : Array[RecoveryScheduleEntry]
  total_time_minutes : Int
  target_window_minutes : Int
  dependency_lower_bound_minutes : Int
  resource_lower_bound_minutes : Int
  slack_minutes : Int
}

pub(all) struct RecoveryPlaybook {
  id : String
  steps : Array[RecoveryStep]
  status : PlaybookStatus
}

pub(all) struct RecoveryScheduleEntry {
  item : RecoveryItem
  start_minutes : Int
  end_minutes : Int
}

pub(all) struct RecoveryStep {
  id : String
  asset : AssetRef
  owner : String
  requires_approval : Bool
  prerequisites : Array[String]
  status : StepStatus
}

pub(all) enum Role {
  Viewer
  Operator
  Approver
  Administrator
}

pub(all) struct ServiceId {
  value : String
}

pub(all) enum StepStatus {
  Pending
  AwaitingApproval
  InProgress
  Succeeded
}

pub(all) struct TechnicalComponent {
  id : ComponentId
  name : String
  technology : String
}

pub(all) struct TimeSpan {
  amount : Int
  unit : TimeUnit
}

pub(all) enum TimeUnit {
  Minutes
  Hours
  Days
}

fn assess_business_impact(service_id~ : ServiceId, impact_score~ : Int, rto~ : TimeSpan, rpo~ : TimeSpan, max_tolerable_downtime~ : TimeSpan) -> BusinessImpactAssessment raise ModelError

fn create_drill(id~ : String, playbook~ : RecoveryPlaybook) -> RecoveryDrill raise ModelError

fn create_playbook(id~ : String, steps~ : Array[RecoveryStep]) -> RecoveryPlaybook raise ModelError

fn create_recovery_step(id~ : String, asset~ : AssetRef, owner~ : String, requires_approval~ : Bool, prerequisites~ : Array[String]) -> RecoveryStep raise ModelError

fn define_dependency(dependent~ : AssetRef, dependency~ : AssetRef) -> Dependency raise ModelError

fn dependency_order(assets : Array[AssetRef], dependencies : Array[Dependency]) -> Array[AssetRef] raise ModelError

fn integration_probe() -> String

fn order_dependencies(assets~ : Array[AssetRef], dependencies~ : Array[Dependency]) -> Array[AssetRef] raise ModelError

fn plan_recovery(items~ : Array[RecoveryItem], dependencies~ : Array[Dependency], constraints~ : RecoveryConstraints) -> RecoveryPlan raise ModelError

fn prioritize_recovery(items~ : Array[RecoveryItem], dependencies~ : Array[Dependency], constraints~ : RecoveryConstraints) -> RecoveryPlan raise ModelError

fn register_component(id~ : ComponentId, name~ : String, technology~ : String) -> TechnicalComponent raise ModelError

fn register_service(id~ : ServiceId, name~ : String, owner~ : String) -> BusinessService raise ModelError

fn simulate_impact(failed_asset~ : AssetRef, assets~ : Array[AssetRef], dependencies~ : Array[Dependency]) -> IncidentImpact raise ModelError

fn simulate_incident_impact(failed_asset~ : AssetRef, assets~ : Array[AssetRef], dependencies~ : Array[Dependency]) -> IncidentImpact raise ModelError

fn validate_dependencies(assets~ : Array[AssetRef], dependencies~ : Array[Dependency]) -> Unit raise ModelError

fn validate_dependency_graph(assets : Array[AssetRef], dependencies : Array[Dependency]) -> Unit raise ModelError