pub(all) struct AuditReport {
  plan : Plan
  overlaps : Array[Overlap]
  dependency_issues : Array[DependencyIssue]
  freeze_conflicts : Array[FreezeConflict]
  blocked_minutes : Int
}

pub(all) enum ChangeKind {
  Added
  Removed
  Modified
} derive(Eq)

pub(all) struct DependencyIssue {
  window_id : String
  dependency : String
  problem : DependencyProblem
  severity : Severity
  detail : String
}

pub(all) enum DependencyProblem {
  MissingDependency
  SelfDependency
  OutOfOrder
  BackToBack
} derive(Eq)

pub(all) struct Diagnostic {
  severity : Severity
  code : String
  line : Int
  detail : String
}

pub(all) struct FreezeConflict {
  window_id : String
  freeze_id : String
  minutes : Int
}

pub(all) enum Impact {
  Critical
  Major
  Minor
} derive(Eq)

pub(all) struct LoadPoint {
  start : Int
  count : Int
}

pub(all) struct Overlap {
  first : String
  second : String
  minutes : Int
  impact : Impact
}

pub(all) struct PeakConcurrency {
  minute : Int
  count : Int
}

pub(all) struct Plan {
  windows : Array[Window]
  diagnostics : Array[Diagnostic]
}

pub(all) struct PlanDiff {
  changes : Array[WindowChange]
  added_windows : Int
  removed_windows : Int
  modified_windows : Int
  new_overlaps : Array[Overlap]
  resolved_overlaps : Int
  new_freeze_conflicts : Array[FreezeConflict]
  resolved_freeze_conflicts : Int
}

pub(all) struct PlanSummary {
  changes : Int
  freezes : Int
  blocked_minutes : Int
  change_minutes : Int
  low_risk : Int
  medium_risk : Int
  high_risk : Int
  earliest : Int?
  latest : Int?
  span_minutes : Int
  peak : PeakConcurrency?
  services : Array[ServiceSummary]
}

pub(all) struct Policy {
  max_concurrent : Int
  max_change_minutes : Int
  min_dependency_slack_minutes : Int
  forbid_high_risk_overlap : Bool
  max_high_risk_per_day : Int
  forbid_freeze_conflicts : Bool
  require_service : Bool
}

pub(all) struct PolicyReport {
  plan : Plan
  audit : AuditReport
  policy : Policy
  violations : Array[PolicyViolation]
}

pub(all) struct PolicyViolation {
  code : String
  severity : Severity
  subject : String
  detail : String
}

pub(all) enum Risk {
  Low
  Medium
  High
} derive(Eq)

pub(all) struct ScheduleCheck {
  candidate : Slot
  allowed : Bool
  reasons : Array[String]
  change_conflicts : Array[SlotConflict]
  freeze_ids : Array[String]
}

pub(all) struct ScheduledChange {
  id : String
  start : Int
  end : Int
  original_start : Int
  shift_minutes : Int
}

pub(all) struct ServiceSummary {
  service : String
  changes : Int
  blocked_minutes : Int
  peak_concurrency : Int
  high_risk_changes : Int
}

pub(all) enum Severity {
  Error
  Warning
} derive(Eq)

pub(all) struct Slot {
  start : Int
  end : Int
}

pub(all) struct SlotConflict {
  window_id : String
  minutes : Int
}

pub(all) struct Window {
  id : String
  service : String
  start : Int
  end : Int
  risk : Risk
  depends : Array[String]
  kind : WindowKind
}

pub(all) struct WindowChange {
  id : String
  kind : ChangeKind
  detail : String
}

pub(all) enum WindowKind {
  Change
  Freeze
} derive(Eq)

fn audit(plan : Plan) -> AuditReport

fn audit_with_policy(plan : Plan, policy : Policy) -> PolicyReport

fn blocked_intervals(plan : Plan) -> Array[Slot]

fn blocked_minutes(plan : Plan) -> Int

fn busiest_intervals(plan : Plan, min_count : Int) -> Array[Slot]

fn can_schedule(plan : Plan, candidate : Slot, depends : Array[String], min_minutes : Int) -> ScheduleCheck

fn candidate_slot(start : Int, end : Int) -> Slot

fn change_minutes(plan : Plan) -> Int

fn clip_slot(slot : Slot, from : Int, to : Int) -> Slot?

fn concurrency_at(plan : Plan, minute : Int) -> Int

fn csv_escape(text : String) -> String

fn dependencies_of(plan : Plan, id : String) -> Array[String]

fn dependency_depth(plan : Plan, id : String) -> Int

fn dependents_of(plan : Plan, id : String) -> Array[String]

fn diff_plans(before : Plan, after : Plan) -> PlanDiff

fn earliest_schedule(plan : Plan) -> Array[ScheduledChange]?

fn earliest_start(plan : Plan, candidate : Slot, min_minutes : Int, search_minutes : Int) -> Int?

fn execution_order(plan : Plan) -> Array[String]?

fn find_cycles(plan : Plan) -> Array[Array[String]]

fn find_service(summary : PlanSummary, service : String) -> ServiceSummary?

fn format_duration(minutes : Int) -> String

fn format_instant(minutes : Int) -> String

fn freeze_conflicts(plan : Plan) -> Array[FreezeConflict]

fn freeze_minutes(plan : Plan) -> Int

fn freezes_hit_by(plan : Plan, candidate : Slot) -> Array[Window]

fn graph_leaves(plan : Plan) -> Array[String]

fn graph_roots(plan : Plan) -> Array[String]

fn intersect_slots(left : Array[Slot], right : Array[Slot]) -> Array[Slot]

fn invert_slots(slots : Array[Slot], from : Int, to : Int) -> Array[Slot]

fn json_escape(text : String) -> String