pub(all) struct AcceptancePolicy {
  warning_uncertainty_ratio : Double
  fail_uncertainty_ratio : Double
  minimum_cpk : Double
  minimum_samples : Int
  allow_unmeasured : Bool
}

pub(all) struct AdapterContract {
  kind : AdapterKind
  supported_kinds : Array[FeatureKind]
  required_fields : Array[String]
}

pub(all) enum AdapterKind {
  Cmm
  Vision
  Laser
  OpcUa
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct AuditEntry {
  feature_id : String
  device_id : String
  strategy : Strategy
  uncertainty : Double
  verdict : Verdict
}

pub(all) struct AuditTrace {
  part_id : String
  entries : Array[AuditEntry]
  warnings : Array[String]
  coverage : Double
  capability : Bool
}

pub(all) struct BatchQualityResult {
  feature_id : String
  observed_count : Int
  defect_rate : Double
  cpk : Double
  decision : QualityDecision
}

pub(all) struct BatchSummary {
  feature_id : String
  count : Int
  pass_count : Int
  fail_count : Int
  unmeasured_count : Int
  mean : Double
  minimum : Double?
  maximum : Double?
  range : Double
  standard_deviation : Double
  defect_rate : Double
  capability : CapabilitySummary
}

pub(all) struct CapabilitySummary {
  cp : Double
  cpk : Double
  adequate : Bool
  sample_count : Int
  uncertainty : Double
}

pub(all) struct Catalog {
  features : Array[Feature]
  devices : Array[Device]
}

pub(all) struct ControlLimits {
  center : Double
  lower : Double
  upper : Double
  sensitivity : Double
}

pub(all) struct DashboardCard {
  key : String
  label : String
  value : String
  status : String
}

pub(all) struct Device {
  id : String
  accuracy : Double
  reach : Double
  supported_kinds : Array[FeatureKind]
}

pub(all) struct DeviceCandidate {
  device_id : String
  device : Device
  score : Double
  reason : SelectionReason
}

pub(all) struct DeviceProfile {
  device : Device
  calibration_date : String
  calibration_expiry : String
  owner : String
}

pub(all) struct Diagnostic {
  code : String
  message : String
  index : Int
  severity : DiagnosticSeverity
}

pub(all) enum DiagnosticSeverity {
  Info
  Warning
  Error
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct DurationEstimate {
  step_count : Int
  sample_count : Int
  seconds : Double
  setup_seconds : Double
  measurement_seconds : Double
  transfer_seconds : Double
}

pub(all) struct EvidenceIndex {
  observation_count : Int
  unique_feature_count : Int
  duplicate_feature_count : Int
  sample_count : Int
  feature_ids : Array[String]
}

pub(all) struct ExecutionPhase {
  phase : PlanPhase
  steps : Array[MeasurementStep]
  device_id : String
}

pub(all) struct Feature {
  id : String
  kind : FeatureKind
  nominal : Double
  lower : Double
  upper : Double
  datum : Bool
}

pub(all) enum FeatureKind {
  Hole
  Shaft
  Plane
  Slot
  Circle
  Cylinder
  Datum
} derive(Eq)

pub(all) struct FeatureResult {
  feature_id : String
  verdict : Verdict
  deviation : Double
  risk : RiskLevel
  sample_count : Int
}

pub(all) struct MeasurementContext {
  operator : String
  instrument : String
  environment : String
  timestamp : String
}

pub(all) struct MeasurementPlan {
  part_id : String
  steps : Array[MeasurementStep]
  summary : PlanSummary
}

pub(all) struct MeasurementProtocol {
  part_id : String
  revision : String
  step_count : Int
  sample_count : Int
  duration_seconds : Double
  preconditions : Array[String]
  acceptance_checks : Array[String]
  warnings : Array[String]
}

pub(all) struct MeasurementStep {
  feature_id : String
  device_id : String
  strategy : Strategy
  direction : String
  uncertainty : Double
}

pub(all) struct Observation {
  feature_id : String
  value : Double
  sample_count : Int
}

pub(all) struct ObservationAnalysis {
  feature_id : String
  count : Int
  summary : BatchSummary
  within_control_limit_count : Int
  outlier_count : Int
  mean_residual : Double
  trend : String
  repeat_consistent : Bool
}

pub(all) struct ObservationBatch {
  feature_id : String
  observations : Array[Observation]
  context : MeasurementContext
}

pub(all) enum OptimizationGoal {
  MinimizeDevices
  MinimizeTime
  MinimizeUncertainty
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct OptimizationResult {
  goal : OptimizationGoal
  schedule : ScheduledPlan
  baseline_score : Double
  optimized_score : Double
  improvement : Double
}

pub(all) struct ParsedFeatures {
  features : Array[Feature]
  diagnostics : Array[Diagnostic]
}

pub(all) struct ParsedObservations {
  observations : Array[Observation]
  diagnostics : Array[Diagnostic]
}

pub(all) struct PlanExplanation {
  feature_id : String
  device_id : String
  reason : SelectionReason
  message : String
}

pub(all) struct PlanMetrics {
  step_count : Int
  single_count : Int
  repeated_count : Int
  scan_count : Int
  device_count : Int
  device_switches : Int
  estimated_samples : Int
  estimated_seconds : Double
  total_uncertainty : Double
  average_uncertainty : Double
  maximum_uncertainty : Double
  minimum_uncertainty : Double
  datum_count : Int
  normal_count : Int
  warning_count : Int
}

pub(all) enum PlanPhase {
  EstablishDatum
  Calibrate
  Measure
  Verify
  Closeout
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct PlanSummary {
  coverage : Double
  capability : Bool
  steps : Int
  warnings : Array[String]
}

pub(all) struct ProgramSummary {
  feature_count : Int
  observed_feature_count : Int
  pass_count : Int
  fail_count : Int
  unmeasured_count : Int
  coverage : Double
  pass_rate : Double
  defect_rate : Double
  mean_cpk : Double
  minimum_cpk : Double
  high_risk_count : Int
  warning_count : Int
}

pub(all) struct QualityDashboard {
  part_id : String
  summary : ProgramSummary
  cards : Array[DashboardCard]
  status : String
}

pub(all) enum QualityDecision {
  Pass
  Warning(reason~ : String)
  Fail(reason~ : String)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct QualityScore {
  coverage : Double
  capability : Bool
  warning_count : Int
  score : Double
}

pub(all) struct QualityTrendSummary {
  batch_count : Int
  total_samples : Int
  total_defects : Int
  defect_rate : Double
  minimum_rate : Double
  maximum_rate : Double
  average_rate : Double
}

pub(all) struct ReadinessReport {
  catalog_diagnostics : Array[Diagnostic]
  observation_diagnostics : Array[Diagnostic]
  plan_diagnostics : Array[Diagnostic]
  error_count : Int
  warning_count : Int
  ready : Bool
}

pub(all) struct ReleaseCheck {
  name : String
  passed : Bool
  detail : String
}

pub(all) struct ReleaseGate {
  part_id : String
  checks : Array[ReleaseCheck]
  ready : Bool
  risk : String
}

pub(all) struct ReplayIssue {
  kind : ReplayIssueKind
  index : Int
  message : String
}

pub(all) enum ReplayIssueKind {
  PartIdentifier
  StepCount
  FeatureIdentifier
  DeviceIdentifier
  Strategy
  Direction
  Uncertainty
  Coverage
  Capability
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ReplayResult {
  expected_part_id : String
  actual_part_id : String
  expected_steps : Int
  actual_steps : Int
  matches : Bool
  issues : Array[ReplayIssue]
}

pub(all) struct ReportManifest {
  schema_version : Int
  application_version : String
  part_id : String
  feature_count : Int
  observation_count : Int
  step_count : Int
  warning_count : Int
  evidence_coverage : Double
  reproducible : Bool
  status : String
}

pub(all) struct ResultCollection {
  feature_ids : Array[String]
  results : Array[FeatureResult]
  pass_count : Int
  fail_count : Int
  unmeasured_count : Int
}

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

pub(all) struct RiskMatrix {
  low_count : Int
  medium_count : Int
  high_count : Int
  total_count : Int
}

pub(all) struct SchedulePolicy {
  datum_first : Bool
  group_by_device : Bool
  max_batch_size : Int
}

pub(all) struct ScheduledPlan {
  part_id : String
  steps : Array[MeasurementStep]
  phases : Array[ExecutionPhase]
  batches : Array[Array[MeasurementStep]]
  phase_count : Int
  device_switches : Int
  estimated_seconds : Double
}

pub(all) enum SelectionReason {
  Supported
  UnsupportedKind
  OutOfReach
  InsufficientCapability
  NoCandidate
  LowerScore
  StableTieBreak
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub enum Strategy {
  SinglePoint
  RepeatedPoint(count~ : Int)
  Scan(count~ : Int)
}

pub(all) struct TraceEvent {
  kind : TraceEventKind
  part_id : String
  feature_id : String
  step_index : Int
  message : String
}

pub(all) enum TraceEventKind {
  PlanStarted
  PlanStep
  ObservationRecorded
  DecisionIssued
  WarningIssued
  PlanFinished
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct TraceLog {
  part_id : String
  events : Array[TraceEvent]
}

pub(all) struct TrendPoint {
  batch_id : String
  sample_count : Int
  defect_count : Int
}

pub(all) struct ValidationSummary {
  error_count : Int
  warning_count : Int
  is_valid : Bool
  first_error_code : String
}

pub(all) struct ValueQualityResult {
  feature_id : String
  value : Double
  normalized_deviation : Double
  uncertainty : Double
  decision : QualityDecision
}

pub enum Verdict {
  Pass
  Fail(reason~ : String)
  Unmeasured
}

fn acceptance_policy(warning_uncertainty_ratio~ : Double, fail_uncertainty_ratio~ : Double, minimum_cpk~ : Double, minimum_samples~ : Int, allow_unmeasured~ : Bool) -> AcceptancePolicy

fn adapter_can_measure(contract : AdapterContract, kind : FeatureKind) -> Bool

fn adapter_contract(kind : AdapterKind, supported_kinds : Array[FeatureKind]) -> AdapterContract

fn adapter_contract_is_valid(contract : AdapterContract) -> Bool

fn adapter_contract_summary(contract : AdapterContract) -> String

fn adapter_for_kind(kind : FeatureKind) -> AdapterContract

fn adapter_is_online(kind : AdapterKind) -> Bool

fn adapter_kind_from_name(name : String) -> AdapterKind?

fn adapter_kind_intersection(left : AdapterContract, right : AdapterContract) -> Array[FeatureKind]

fn adapter_name(kind : AdapterKind) -> String

fn adapter_priority(kind : AdapterKind) -> Int

fn adapter_required_field_count(contract : AdapterContract) -> Int

fn adapter_requires_calibration(kind : AdapterKind) -> Bool

fn adapter_selection_reason(contract : AdapterContract, kind : FeatureKind) -> String

fn adapter_supported_kind_count(contract : AdapterContract) -> Int

fn adapter_supports_batch(kind : AdapterKind) -> Bool

fn adapters_overlap(left : AdapterContract, right : AdapterContract) -> Bool

fn all_adapter_kinds() -> Array[AdapterKind]

fn all_feature_kinds() -> Array[FeatureKind]

fn all_features_reachable(catalog : Catalog) -> Bool

fn analysis_risk(analysis : ObservationAnalysis) -> RiskLevel

fn analyze_observations(feature~ : Feature, observations~ : Array[Observation], uncertainty~ : Double) -> ObservationAnalysis

fn assess_readiness(features~ : Array[Feature], devices~ : Array[Device], plan~ : MeasurementPlan, observations~ : Array[Observation]) -> ReadinessReport

fn audit_verdict_counts(trace : AuditTrace) -> (Int, Int, Int)

fn average_step_duration(plan : MeasurementPlan) -> Double

fn batch_is_clean(summary : BatchSummary) -> Bool

fn batch_size_is_valid(batches : Array[Array[MeasurementStep]], max_batch_size : Int) -> Bool

fn batch_trend(values : Array[Double]) -> String

fn benchmark_devices() -> Array[Device]

fn benchmark_feature_csv() -> String

fn benchmark_features() -> Array[Feature]

fn benchmark_observations() -> Array[Observation]

fn benchmark_plan() -> MeasurementPlan

fn build_audit_trace(plan~ : MeasurementPlan, observations~ : Array[Observation]) -> AuditTrace

fn build_audit_trace_with_features(plan~ : MeasurementPlan, features~ : Array[Feature], observations~ : Array[Observation]) -> AuditTrace

fn build_dashboard(features~ : Array[Feature], observations~ : Array[Observation], plan~ : MeasurementPlan) -> QualityDashboard

fn build_evidence_index(observations : Array[Observation]) -> EvidenceIndex

fn build_report_manifest(plan : MeasurementPlan, features : Array[Feature], observations : Array[Observation], application_version : String) -> ReportManifest

fn build_risk_matrix(collection : ResultCollection) -> RiskMatrix

fn calibration_is_current(profile : DeviceProfile, date : String) -> Bool

fn canonical_feature_line(feature : Feature) -> String

fn canonical_observation_line(observation : Observation) -> String

fn canonical_part_id(part_id : String) -> String

fn capability_indices(feature~ : Feature, values~ : Array[Double], uncertainty~ : Double) -> CapabilitySummary