pub(all) suberror ProcessError {
  InvalidLog(path~ : String, reason~ : String)
  Capacity(resource~ : String, limit~ : Int)
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ActivityNode {
  activity : String
  occurrences : Int
  cases : Int
  starts : Int
  ends : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ActivityPerformance {
  activity : String
  service : DurationDistribution
}

pub struct AlignmentCosts {
  unexpected : Int
  missing : Int
}

pub(all) enum AlignmentMove {
  Synchronous(event_id~ : String, activity~ : String)
  Unexpected(event_id~ : String, activity~ : String)
  Missing(activity~ : String)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct AlignmentSpec {
  // private fields
}

pub(all) struct BpmnFlow {
  id : String
  source : String
  target : String
}

pub(all) enum BpmnKind {
  Start
  End
  Task
  Exclusive
  Parallel
}

pub struct BpmnModel {
  // private fields
}

pub(all) struct BpmnNode {
  id : String
  kind : BpmnKind
  activity : String?
}

pub(all) struct CasePerformance {
  case_id : String
  events : Int
  cycle_time : Int64
  busy_union : Int64
  idle_time : Int64
  service_work : Double
  overlapping_starts : Int
}

pub(all) struct CaseSelection {
  require_activities : Array[String]
  exclude_activities : Array[String]
  minimum_cycle : Int64?
  maximum_cycle : Int64?
  starts_from : Int64?
  starts_before : Int64?
}

pub struct CaseTrace {
  // private fields
}

pub(all) struct CohortComparison {
  before_cases : Int
  after_cases : Int
  total_variation : Double
  variants : Array[VariantDelta]
}

pub(all) struct DurationDistribution {
  count : Int
  minimum : Int64?
  maximum : Int64?
  median : Int64?
  p95 : Int64?
  mean : Double?
}

pub struct EventLog {
  // private fields
}

pub(all) struct FlowEdge {
  source : String
  target : String
  occurrences : Int
  cases : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct FlowWindow {
  started : Int64
  completed : Int64
  cases_started : Int
  cases_completed : Int
  active_at_start : Int
  active_before_end : Int
  observed_work_area : Double
  mean_observed_wip : Double
  completed_cycles : DurationDistribution
}

pub(all) struct HandoffPerformance {
  source : String
  target : String
  positive_gap : DurationDistribution
  overlapping_pairs : Int
}

pub struct LogEvent {
  id : String
  case_id : String
  activity : String
  started : Int64
  completed : Int64
  resource : String?
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ModelAlignment {
  case_id : String
  cost : Int
  conforming : Bool
  moves : Array[NetMove]
  visited_states : Int
  explored_edges : Int
  transition_checks : Int
  reused_variant : Bool
}

pub(all) struct ModelAnalysis {
  complete : Bool
  states : Int
  edges : Int
  final_reachable : Bool
  all_states_can_complete : Bool
  proper_completion : Bool
  dead_transitions : Array[String]
  deadlock_markings : Array[Array[Int]]
}

pub(all) struct ModelLimits {
  states : Int
  edges : Int
  tokens_per_place : Int
}

pub(all) struct NetArc {
  source : String
  target : String
  weight : Int
}

pub(all) enum NetMove {
  Sync(event_id~ : String, transition~ : String, activity~ : String)
  LogOnly(event_id~ : String, activity~ : String)
  ModelOnly(transition~ : String, activity~ : String?)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct NetTransition {
  id : String
  activity : String?
}

pub(all) struct PerformanceReport {
  cases : Array[CasePerformance]
  activities : Array[ActivityPerformance]
  handoffs : Array[HandoffPerformance]
  resources : Array[ResourcePerformance]
  cycle_times : DurationDistribution
}

pub struct PetriNet {
  // private fields
}

pub(all) struct PlaceTokens {
  place : String
  tokens : Int
}

pub(all) struct PolicyResult {
  case_id : String
  policy : String
  status : PolicyStatus
  event_ids : Array[String]
}

pub(all) enum PolicyStatus {
  Satisfied
  Violated
  Inconclusive
  NotApplicable
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ProcessMap {
  nodes : Array[ActivityNode]
  edges : Array[FlowEdge]
  variants : Array[ProcessVariant]
  cases : Int
  events : Int
}

pub(all) enum ProcessPolicy {
  Response(id~ : String, trigger~ : String, target~ : String, within_ms~ : Int64?)
  Precedence(id~ : String, trigger~ : String, required~ : String)
  NotCoexist(id~ : String, first~ : String, second~ : String)
  SeparationOfDuties(id~ : String, first~ : String, second~ : String)
}

pub(all) struct ProcessVariant {
  activities : Array[String]
  cases : Array[String]
}

pub struct ReferencePath {
  // private fields
}

pub(all) struct ResourceHandoff {
  source : String
  target : String
  occurrences : Int
  cases : Int
}

pub(all) struct ResourceOccupancy {
  started : Int64
  completed : Int64
  active : Int
}

pub(all) struct ResourcePerformance {
  resource : String
  occurrences : Int
  service : DurationDistribution
  maximum_concurrency : Int
}

pub(all) struct TraceAlignment {
  case_id : String
  reference : String
  cost : Int
  fitness : Double
  moves : Array[AlignmentMove]
  evaluated_cells : Int
}

pub(all) struct VariantDelta {
  activities : Array[String]
  before_cases : Int
  after_cases : Int
}

pub(all) enum XesMode {
  Completed
  LifecyclePairs
}

fn alignment_to_json(result : TraceAlignment) -> Json

fn cohort_comparison_to_json(result : CohortComparison) -> Json

fn log_to_json(log : EventLog) -> Json

fn model_alignment_to_json(result : ModelAlignment) -> Json

fn model_analysis_to_json(report : ModelAnalysis) -> Json

fn parse_alignment_spec(text : String) -> AlignmentSpec raise ProcessError

fn parse_bpmn(text : String) -> BpmnModel raise ProcessError

fn parse_log(text : String) -> EventLog raise ProcessError

fn parse_net(text : String) -> PetriNet raise ProcessError

fn parse_pnml(text : String) -> PetriNet raise ProcessError

fn parse_policies(text : String) -> Array[ProcessPolicy] raise ProcessError

fn parse_xes(text : String, mode? : XesMode) -> EventLog raise ProcessError

fn performance_to_json(report : PerformanceReport) -> Json

fn policy_results_to_json(results : Array[PolicyResult]) -> Json

fn process_map_to_json(map : ProcessMap) -> Json

fn resource_handoffs_to_json(result : Array[ResourceHandoff]) -> Json