🥮 mooncakes.io

moonbit-triage

Explainable emergency triage scoring primitives for MoonBit.

triage
NEWS2
qSOFA
GCS
SOFA
HEART
Wells
clinical-score
audit
observability
risk-stratification
moon add agentdebug799/moonbit-triage@0.4.0
Download zip
Version
0.4.0
License
Apache-2.0
Repository
Last updated
7 hours ago
Downloads
6
README

#moonbit-triage

moonbit-triage is a dependency-free MoonBit library for explainable, auditable clinical score computation in education, software validation, data-quality pipelines, and prototype integrations. It returns component contributions and structured range errors so a caller can inspect exactly how a result was made.

The library computes early-warning, cardiorespiratory, neurologic, trauma, gastrointestinal, renal/hepatic, perioperative, and pediatric/obstetric scores, including NEWS2, qSOFA, GCS, SIRS, MEWS, SOFA, PEWS, CURB-65, Shock Index, ROX, Wells, HEART, CHA2DS2-VASc, PESI, BODE, qCSI, Hestia, RTS, ISS, NIHSS, FOUR, ABCD2, APACHE II, SMART-COP, Caprini, Padua, STOP-Bang, ARISCAT, Child-Pugh, MELD-Na, Glasgow-Blatchford, AKI, BISAP, Ranson, Alvarado, Bishop, and preeclampsia feature checks. It also provides observation timelines, assessment ledgers, pathway decisions, audit events, registry diffs, batch summaries, and measurement-quality flags.

#Core capabilities

  • Typed inputs with explicit inclusive threshold functions.
  • Component-level explanations and stable severity bands.
  • First-error validation for common measurement ranges.
  • Integer-scaled ratio APIs (Shock Index x100, ROX Index x100) for portable, deterministic results across MoonBit targets.
  • Batch summaries and quality flags for form or data-pipeline integration.
  • Observation timelines, trend extraction, threshold evaluation, and freshness checks for longitudinal data.
  • Assessment ledgers, deterministic pathway escalation, audit events, and a versioned instrument registry for traceable integrations.
  • No external runtime dependencies; wasm-gc is the preferred target.

#Quick start

moon check
moon test
moon run cmd/main

The runnable CLI prints a combined NEWS2/qSOFA/GCS assessment and its summary. For a deterministic workload used by the benchmark section, run:

moon run cmd/benchmark

#CLI

The example CLI is intentionally small and demonstrates the public API rather than acting as a clinical decision system. Applications can construct records, call score_*, inspect ScoreReport.explanations, and route validation errors through their own forms or service boundaries.

#Minimal example

///|
test "README NEWS2 example" {
  let report = @moonbit-triage.score_news2({
    respiratory_rate: 16,
    oxygen_saturation: 98,
    spo2_scale: @moonbit-triage.Scale1,
    supplemental_oxygen: false,
    temperature_tenths_c: 370,
    systolic_bp: 120,
    heart_rate: 72,
    consciousness: @moonbit-triage.Alert,
  })
  inspect(report.score, content="0")
  debug_inspect(report.severity, content="Low")
}

#Architecture and API shape

The public API intentionally uses plain records and enums so that callers can wire the library into CLI tools, web forms, or data-validation pipelines without extra dependencies. Each ScoreReport includes:

  • instrument: scoring instrument name.
  • score: numeric total.
  • severity: local library band for software routing.
  • interpretation: short explanation of the band.
  • explanations: component-level point contributions.
  • disclaimer: safety boundary text.

The root package owns the public data types and scoring facade. Focused files contain each instrument family; observation_pipeline.mbt handles longitudinal measurements, assessment.mbt handles score snapshots, pathway.mbt handles escalation and audit events, and registry*.mbt handles instrument metadata and release diffs. quality.mbt handles measurement metadata and batch.mbt handles deterministic aggregation. The generated pkg.generated.mbti is checked in as a compact public API review surface.

#Sources and safety

The implementation follows publicly described scoring thresholds for NEWS2, qSOFA, and GCS. The qSOFA criteria are also summarized by the public qSOFA project: respiratory rate at least 22/min, systolic blood pressure at most 100 mmHg, and GCS below 15. Clinical scoring rules can be embedded in local protocols differently, so downstream projects should review the thresholds against their intended policy before use.

This project is for education, audit, and software validation. It is not a medical device and must not replace clinician judgment.

Rule provenance, primary reference links, implementation scope, and explicit non-claims are documented in PROVENANCE.md.

Every score is a rule implementation, not a diagnosis. This package must not be used as a substitute for clinician judgment, local policy, or a regulated medical-device workflow. Downstream users are responsible for validating the chosen thresholds, patient population, units, and escalation policy.

#Benchmarks

The checked-in benchmark runs 10,000 NEWS2 calculations and prints a checksum and count, making correctness and workload size reproducible without claiming hardware-independent latency. On the maintainer workstation with MoonBit 0.1.20260807, the command produced:

iterations=10000
checksum=54000
critical_reports=4500

Measure wall-clock time locally with PowerShell (Measure-Command { moon runcmd/benchmark }) or /usr/bin/time on Unix; report the machine and toolchain when comparing runs.

#Tests and CI

The test suite covers threshold transitions, invalid ranges, aggregate scores, clinical edge cases, longitudinal data quality, pathway decisions, registry diffs, report serialization, and deterministic summaries. The current native coverage run executes 2,349 of 3,354 instrumented lines (70.0%). GitHub Actions runs formatting, all-target checks, public API generation, wasm-gc tests, native tests, and a coverage summary on Linux, macOS, and Windows.

#Development notes

  • MoonBit module: agentdebug799/moonbit-triage.
  • License: Apache-2.0.
  • Preferred target: wasm-gc.
  • Validation used for release: moon fmt --check, moon check --deny-warn, moon info, moon test --deny-warn, and the benchmark command.

#License

Apache-2.0. See LICENSE.

#
Abcd2Input

source
pub(all) struct Abcd2Input {
  age : Int
  systolic_bp : Int
  diastolic_bp : Int
  unilateral_weakness : Bool
  speech_impairment_without_weakness : Bool
  symptom_duration_minutes : Int
  diabetes : Bool
} derive(Eq, 
Debug)

#
AkiInput

source
pub(all) struct AkiInput {
  baseline_creatinine_hundredths : Int
  current_creatinine_hundredths : Int
  urine_rate_hundredths_ml_kg_h : Int
  urine_duration_hours : Int
} derive(Eq, 
Debug)

#
AlvaradoInput

source
pub(all) struct AlvaradoInput {
  migration_of_pain : Bool
  anorexia : Bool
  nausea_or_vomiting : Bool
  right_lower_quadrant_tenderness : Bool
  rebound_tenderness : Bool
  fever_tenths_c : Int
  leukocytosis : Bool
  left_shift : Bool
} derive(Eq, 
Debug)

#
ApacheIiInput

source
pub(all) struct ApacheIiInput {
  temperature_tenths_c : Int
  mean_arterial_pressure : Int
  heart_rate : Int
  respiratory_rate : Int
  oxygenation_value : Int
  high_fio2 : Bool
  arterial_ph_hundredths : Int
  sodium : Int
  potassium_tenths : Int
  creatinine_hundredths : Int
  acute_renal_failure : Bool
  hematocrit_tenths : Int
  white_cell_count_tenths : Int
  gcs : Int
  age : Int
  chronic_health : Bool
} derive(Eq, 
Debug)

#
AriscatInput

source
pub(all) struct AriscatInput {
  age : Int
  preoperative_oxygen_saturation : Int
  respiratory_infection_last_month : Bool
  preoperative_anemia : Bool
  surgical_incision_site : Int
  expected_duration_minutes : Int
  emergency_surgery : Bool
} derive(Eq, 
Debug)

#
AssessmentLedger

source
pub(all) struct AssessmentLedger {
  snapshots : Array[ScoreSnapshot]
  last_timestamp_minutes : Int
} derive(Eq, 
Debug)

#
AssessmentSummary

source
pub(all) struct AssessmentSummary {
  snapshots : Int
  instruments : Int
  total_score : Int
  highest : Severity
  latest_timestamp_minutes : Int
} derive(Eq, 
Debug)

#
AuditEvent

source
pub(all) struct AuditEvent {
  sequence : Int
  event_type : String
  instrument : String
  score : Int
  severity : Severity
  timestamp_minutes : Int
  source : String
  note : String
} derive(Eq, 
Debug)

#
BisapInput

source
pub(all) struct BisapInput {
  bun_mmol_l_tenths : Int
  impaired_mentation : Bool
  sirs_criteria : Int
  age : Int
  pleural_effusion : Bool
} derive(Eq, 
Debug)

#
BishopInput

source
pub(all) struct BishopInput {
  dilation_cm : Int
  effacement_percent : Int
  fetal_station : Int
  cervical_consistency : Int
  cervical_position : Int
} derive(Eq, 
Debug)

#
BodeInput

source
pub(all) struct BodeInput {
  body_mass_index : Int
  fev1_percent : Int
  modified_mrc : Int
  six_minute_walk_meters : Int
} derive(Eq, 
Debug)

#
CanadianCspineInput

source
pub(all) struct CanadianCspineInput {
  age : Int
  dangerous_mechanism : Bool
  paresthesias : Bool
  low_risk_simple_rear_end_collision : Bool
  low_risk_sitting_in_ed : Bool
  low_risk_ambulatory : Bool
  low_risk_delayed_neck_pain : Bool
  low_risk_no_midline_tenderness : Bool
  rotates_neck_45_degrees : Bool
} derive(Eq, 
Debug)

#
CanadianCtHeadInput

source
pub(all) struct CanadianCtHeadInput {
  age : Int
  gcs_less_than_15_at_two_hours : Bool
  suspected_open_skull_fracture : Bool
  signs_of_basal_skull_fracture : Bool
  vomiting_episodes : Int
  age_at_least_65 : Bool
  retrograde_amnesia_minutes : Int
  dangerous_mechanism : Bool
  anticoagulant_or_antiplatelet : Bool
} derive(Eq, 
Debug)

#
CapriniInput

source
pub(all) struct CapriniInput {
  age : Int
  bmi_over_25 : Bool
  swollen_legs : Bool
  varicose_veins : Bool
  pregnancy_or_postpartum : Bool
  oral_contraceptives_or_hormone : Bool
  sepsis : Bool
  serious_lung_disease : Bool
  abnormal_pulmonary_function : Bool
  acute_myocardial_infarction : Bool
  congestive_heart_failure : Bool
  inflammatory_bowel_disease : Bool
  medical_patient : Bool
  minor_surgery : Bool
  arthroscopic_surgery : Bool
  major_surgery : Bool
  laparoscopic_surgery_over_45_min : Bool
  malignancy : Bool
  bed_rest_over_72_hours : Bool
  prior_vte : Bool
  family_history_vte : Bool
  thrombophilia : Bool
  stroke : Bool
  elective_arthroplasty : Bool
  hip_pelvis_leg_fracture : Bool
  acute_spinal_cord_injury : Bool
} derive(Eq, 
Debug)

#
Cha2ds2VascInput

source
pub(all) struct Cha2ds2VascInput {
  congestive_failure : Bool
  hypertension : Bool
  age : Int
  diabetes : Bool
  stroke_or_tia : Bool
  vascular_disease : Bool
  sex_female : Bool
} derive(Eq, 
Debug)

#
CharlsonInput

source
pub(all) struct CharlsonInput {
  age : Int
  myocardial_infarction : Bool
  congestive_heart_failure : Bool
  peripheral_vascular_disease : Bool
  cerebrovascular_disease : Bool
  dementia : Bool
  chronic_pulmonary_disease : Bool
  connective_tissue_disease : Bool
  peptic_ulcer_disease : Bool
  mild_liver_disease : Bool
  diabetes_without_complication : Bool
  diabetes_with_end_organ_damage : Bool
  hemiplegia : Bool
  moderate_or_severe_renal_disease : Bool
  any_tumor : Bool
  leukemia : Bool
  lymphoma : Bool
  moderate_or_severe_liver_disease : Bool
  metastatic_solid_tumor : Bool
  aids : Bool
} derive(Eq, 
Debug)

#
ChildPughInput

source
pub(all) struct ChildPughInput {
  bilirubin_tenths_mg_dl : Int
  albumin_tenths_g_dl : Int
  inr_hundredths : Int
  ascites_grade : Int
  encephalopathy_grade : Int
} derive(Eq, 
Debug)

#
Consciousness

source
pub(all) enum Consciousness {
  Alert
  NewConfusion
  Voice
  Pain
  Unresponsive
} derive(Eq, 
Debug)

#
Curbs65Input

source
pub(all) struct Curbs65Input {
  confusion : Bool
  urea_mmol : Int
  respiratory_rate : Int
  systolic_bp : Int
  diastolic_bp : Int
  age : Int
} derive(Eq, 
Debug)

#
EscalationTier

source
pub(all) enum EscalationTier {
  Routine
  Review
  Urgent
  Immediate
} derive(Eq, 
Debug)

#
EvidenceStatus

source
pub(all) enum EvidenceStatus {
  EvidenceComplete
  EvidencePartial
  EvidenceMissing
  EvidenceInvalid
} derive(Eq, 
Debug)

#
Explanation

source
pub(all) struct Explanation {
  label : String
  points : Int
  detail : String
} derive(Eq, 
Debug)

#
FourScoreInput

source
pub(all) struct FourScoreInput {
  eye_response : Int
  motor_response : Int
  brainstem_reflexes : Int
  respiration : Int
} derive(Eq, 
Debug)

#
GcsInput

source
pub(all) struct GcsInput {
  eye : Int
  verbal : Int
  motor : Int
} derive(Eq, 
Debug)

#
GcsReport

source
pub(all) struct GcsReport {
  total : Int
  eye : Int
  verbal : Int
  motor : Int
  severity : Severity
  explanations : Array[Explanation]
  disclaimer : String
} derive(Eq, 
Debug)

#
GlasgowBlatchfordInput

source
pub(all) struct GlasgowBlatchfordInput {
  bun_mmol_l_tenths : Int
  hemoglobin_g_dl_tenths : Int
  female : Bool
  systolic_bp : Int
  pulse : Int
  melena : Bool
  syncope : Bool
  hepatic_disease : Bool
  cardiac_failure : Bool
} derive(Eq, 
Debug)

#
HasBledInput

source
pub(all) struct HasBledInput {
  hypertension : Bool
  abnormal_renal : Bool
  abnormal_liver : Bool
  stroke : Bool
  bleeding_history : Bool
  labile_inr : Bool
  age_over_65 : Bool
  drugs_or_alcohol : Bool
} derive(Eq, 
Debug)

#
HeartInput

source
pub(all) struct HeartInput {
  history : Int
  ecg : Int
  age : Int
  risk_factors : Int
  troponin : Int
} derive(Eq, 
Debug)

#
HestiaInput

source
pub(all) struct HestiaInput {
  unstable : Bool
  oxygen_saturation_low : Bool
  active_bleeding : Bool
  need_thrombolysis : Bool
  severe_renal_impairment : Bool
  severe_liver_impairment : Bool
  social_barrier : Bool
  pregnancy : Bool
  history_bleeding : Bool
  treatment_failure : Bool
} derive(Eq, 
Debug)

#
InjurySeverityInput

source
pub(all) struct InjurySeverityInput {
  head_neck : Int
  face : Int
  chest : Int
  abdomen : Int
  extremity : Int
  external : Int
} derive(Eq, 
Debug)

#
InstrumentCategory

source
pub(all) enum InstrumentCategory {
  EarlyWarning
  Cardiorespiratory
  Neurology
  Trauma
  Gastrointestinal
  RenalHepatic
  Perioperative
  ObstetricPediatric
  Workflow
} derive(Eq, 
Debug)

#
InstrumentMetadata

source
pub(all) struct InstrumentMetadata {
  id : String
  display_name : String
  category : InstrumentCategory
  unit : String
  minimum : Int
  maximum : Int
  source_url : String
  version : String
  caution : String
  keywords : Array[String]
} derive(Eq, 
Debug)

#
InstrumentRegistry

source
pub(all) struct InstrumentRegistry {
  entries : Array[InstrumentMetadata]
  revision : String
} derive(Eq, 
Debug)

#
MeasurementQuality

source
pub(all) enum MeasurementQuality {
  Complete
  Missing
  OutOfRange
  Suspicious
} derive(Eq, 
Debug)

#
MeasurementUnit

source
pub(all) enum MeasurementUnit {
  BeatsPerMinute
  BreathsPerMinute
  MillimetersMercury
  Percent
  CelsiusTenths
  MilligramsPerDeciliter
  MillimolesPerLiter
  MicromolesPerLiter
  ScorePoints
  Unknown
} derive(Eq, 
Debug)

#
MeldNaInput

source
pub(all) struct MeldNaInput {
  bilirubin_tenths_mg_dl : Int
  inr_hundredths : Int
  creatinine_tenths_mg_dl : Int
  sodium : Int
  dialysis_twice_last_week : Bool
} derive(Eq, 
Debug)

#
MewsInput

source
pub(all) struct MewsInput {
  systolic_bp : Int
  heart_rate : Int
  respiratory_rate : Int
  temperature_tenths_c : Int
  consciousness : Consciousness
} derive(Eq, 
Debug)

#
News2Input

source
pub(all) struct News2Input {
  respiratory_rate : Int
  oxygen_saturation : Int
  spo2_scale : Spo2Scale
  supplemental_oxygen : Bool
  temperature_tenths_c : Int
  systolic_bp : Int
  heart_rate : Int
  consciousness : Consciousness
} derive(Eq, 
Debug)

#
NexusCspineInput

source
pub(all) struct NexusCspineInput {
  posterior_midline_tenderness : Bool
  focal_neurologic_deficit : Bool
  altered_alertness : Bool
  intoxication : Bool
  painful_distracting_injury : Bool
} derive(Eq, 
Debug)

#
NihssInput

source
pub(all) struct NihssInput {
  consciousness : Int
  questions : Int
  commands : Int
  gaze : Int
  visual : Int
  facial : Int
  left_arm : Int
  right_arm : Int
  left_leg : Int
  right_leg : Int
  ataxia : Int
  sensory : Int
  language : Int
  dysarthria : Int
  neglect : Int
} derive(Eq, 
Debug)

#
Observation

source
pub(all) struct Observation {
  kind : ObservationKind
  value : Int
  unit : MeasurementUnit
  timestamp_minutes : Int
  source : String
} derive(Eq, 
Debug)

#
ObservationIssue

source
pub(all) enum ObservationIssue {
  NegativeTimestamp
  EmptySource
  UnitMismatch
  NonFiniteRange
} derive(Eq, 
Debug)

#
ObservationKind

source
pub(all) enum ObservationKind {
  HeartRate
  RespiratoryRate
  SystolicBloodPressure
  DiastolicBloodPressure
  OxygenSaturation
  Temperature
  GlasgowComaScale
  WhiteCellCount
  PlateletCount
  Bilirubin
  Creatinine
  Custom
} derive(Eq, 
Debug)

#
OttawaAnkleInput

source
pub(all) struct OttawaAnkleInput {
  posterior_edge_lateral_malleolus_tender : Bool
  posterior_edge_medial_malleolus_tender : Bool
  base_of_fifth_metatarsal_tender : Bool
  navicular_tender : Bool
  unable_to_bear_four_steps : Bool
} derive(Eq, 
Debug)

#
PaduaInput

source
pub(all) struct PaduaInput {
  active_cancer : Bool
  previous_vte : Bool
  reduced_mobility : Bool
  known_thrombophilia : Bool
  recent_trauma_or_surgery : Bool
  elderly_age : Bool
  heart_or_respiratory_failure : Bool
  acute_mi_or_stroke : Bool
  acute_infection_or_rheumatologic : Bool
  bmi_over_30 : Bool
  ongoing_hormonal_treatment : Bool
} derive(Eq, 
Debug)

#
PathwayDecision

source
pub(all) struct PathwayDecision {
  tier : EscalationTier
  evidence : EvidenceStatus
  matched_rules : Array[String]
  missing_instruments : Array[String]
  highest_severity : Severity
  score_count : Int
  explanation : String
} derive(Eq, 
Debug)

#
PathwayRule

source
pub(all) struct PathwayRule {
  code : String
  title : String
  tier : EscalationTier
  required_instruments : Array[String]
  minimum_severity : Severity
  rationale : String
} derive(Eq, 
Debug)

#
PecarnHeadInput

source
pub(all) struct PecarnHeadInput {
  age_under_two : Bool
  altered_mentation : Bool
  palpable_skull_fracture : Bool
  nonfrontal_scalp_hematoma : Bool
  loss_of_consciousness_minutes : Int
  severe_mechanism : Bool
  not_behaving_normally : Bool
  signs_of_basilar_skull_fracture : Bool
  severe_headache : Bool
} derive(Eq, 
Debug)

#
PediatricAppendicitisInput

source
pub(all) struct PediatricAppendicitisInput {
  migration_of_pain : Bool
  anorexia : Bool
  nausea_or_vomiting : Bool
  right_lower_quadrant_tenderness : Bool
  cough_hopping_percussion_pain : Bool
  fever_tenths_c : Int
  leukocytosis : Bool
  neutrophilia : Bool
} derive(Eq, 
Debug)

#
PercInput

source
pub(all) struct PercInput {
  age : Int
  heart_rate : Int
  oxygen_saturation : Int
  hemoptysis : Bool
  estrogen_use : Bool
  prior_vte : Bool
  recent_surgery_or_trauma : Bool
  unilateral_leg_swelling : Bool
} derive(Eq, 
Debug)

#
PesiInput

source
pub(all) struct PesiInput {
  age : Int
  male : Bool
  nursing_home : Bool
  cancer : Bool
  heart_failure : Bool
  chronic_lung_disease : Bool
  heart_rate : Int
  systolic_bp : Int
  temperature_tenths_c : Int
  altered_mentation : Bool
  oxygen_saturation : Int
} derive(Eq, 
Debug)

#
PewsBehavior

source
pub(all) enum PewsBehavior {
  Playing
  Sleeping
  Irritable
  Lethargic
} derive(Eq, 
Debug)

#
PewsCardiovascular

source
pub(all) enum PewsCardiovascular {
  Normal
  Tachycardic
  PoorPerfusion
} derive(Eq, 
Debug)

#
PewsInput

source
pub(all) struct PewsInput {
  behavior : PewsBehavior
  cardiovascular : PewsCardiovascular
  respiratory : PewsRespiratory
  oxygen_support : PewsOxygenSupport
  nebulizer_count : Int
} derive(Eq, 
Debug)

#
PewsOxygenSupport

source
pub(all) enum PewsOxygenSupport {
  RoomAir
  LowFlow
  HighFlow
} derive(Eq, 
Debug)

#
PewsRespiratory

source
pub(all) enum PewsRespiratory {
  Normal
  ModerateDistress
  SevereDistress
} derive(Eq, 
Debug)

#
PreeclampsiaInput

source
pub(all) struct PreeclampsiaInput {
  systolic_bp : Int
  diastolic_bp : Int
  platelets_thousands : Int
  creatinine_hundredths_mg_dl : Int
  ast_units : Int
  alt_units : Int
  pulmonary_edema : Bool
  persistent_headache : Bool
  visual_symptoms : Bool
  right_upper_quadrant_pain : Bool
  fetal_growth_restriction : Bool
} derive(Eq, 
Debug)

#
QcsiInput

source
pub(all) struct QcsiInput {
  respiratory_rate : Int
  oxygen_saturation : Int
  oxygen_flow_liters : Int
} derive(Eq, 
Debug)

#
QsofaInput

source
pub(all) struct QsofaInput {
  respiratory_rate : Int
  systolic_bp : Int
  gcs_total : Int
} derive(Eq, 
Debug)

#
QualityFlag

source
pub(all) struct QualityFlag {
  field : String
  quality : MeasurementQuality
  message : String
} derive(Eq, 
Debug)

#
QualitySummary

source
pub(all) struct QualitySummary {
  total : Int
  complete : Int
  missing : Int
  out_of_range : Int
  suspicious : Int
} derive(Eq, 
Debug)

#
RansonInput

source
pub(all) struct RansonInput {
  age : Int
  wbc_tenths : Int
  glucose_mg_dl : Int
  ldh_units : Int
  ast_units : Int
  hematocrit_drop_tenths : Int
  bun_rise_mg_dl : Int
  calcium_mg_dl_tenths : Int
  arterial_oxygen_mmhg : Int
  base_deficit : Int
  fluid_sequestration_liters : Int
} derive(Eq, 
Debug)

#
RcriInput

source
pub(all) struct RcriInput {
  high_risk_surgery : Bool
  ischemic_heart_disease : Bool
  heart_failure : Bool
  cerebrovascular_disease : Bool
  diabetes_on_insulin : Bool
  creatinine_above_2 : Bool
} derive(Eq, 
Debug)

#
RegistryChange

source
pub(all) struct RegistryChange {
  id : String
  kind : RegistryChangeKind
  before_version : String
  after_version : String
  detail : String
} derive(Eq, 
Debug)

#
RegistryChangeKind

source
pub(all) enum RegistryChangeKind {
  Added
  Removed
  Updated
  Unchanged
} derive(Eq, 
Debug)

#
ReportComparison

source
pub(all) struct ReportComparison {
  left_instrument : String
  right_instrument : String
  left_score : Int
  right_score : Int
  left_more_concerning : Bool
  score_delta : Int
} derive(Eq, 
Debug)

#
ReportQuality

source
pub(all) struct ReportQuality {
  total : Int
  nonempty : Int
  reconciled : Int
  coherent : Bool
  disclaimer_count : Int
} derive(Eq, 
Debug)

#
ReportSummary

source
pub(all) struct ReportSummary {
  count : Int
  total_score : Int
  highest : Severity
  low_count : Int
  medium_count : Int
  high_count : Int
  critical_count : Int
} derive(Eq, 
Debug)

#
RevisedTraumaInput

source
pub(all) struct RevisedTraumaInput {
  gcs_total : Int
  systolic_bp : Int
  respiratory_rate : Int
} derive(Eq, 
Debug)

#
RoxInput

source
pub(all) struct RoxInput {
  oxygen_saturation : Int
  fio2_percent : Int
  respiratory_rate : Int
} derive(Eq, 
Debug)

#
RuleEvaluation

source
pub(all) struct RuleEvaluation {
  rule_name : String
  value : Int
  matched : Bool
  points : Int
  band : String
  explanation : String
} derive(Eq, 
Debug)

#
ScoreReport

source
pub(all) struct ScoreReport {
  instrument : String
  score : Int
  severity : Severity
  interpretation : String
  explanations : Array[Explanation]
  disclaimer : String
} derive(Eq, 
Debug)

#
ScoreSnapshot

source
pub(all) struct ScoreSnapshot {
  instrument : String
  score : Int
  severity : Severity
  timestamp_minutes : Int
  source : String
} derive(Eq, 
Debug)

#
Severity

source
pub(all) enum Severity {
  Low
  Medium
  High
  Critical
} derive(Eq, 
Debug)

#
ShockIndexInput

source
pub(all) struct ShockIndexInput {
  heart_rate : Int
  systolic_bp : Int
} derive(Eq, 
Debug)

#
SirsInput

source
pub(all) struct SirsInput {
  temperature_tenths_c : Int
  heart_rate : Int
  respiratory_rate : Int
  white_cell_count : Int
  immature_neutrophils_percent : Int
} derive(Eq, 
Debug)

#
SmartCopInput

source
pub(all) struct SmartCopInput {
  systolic_bp : Int
  multilobar_infiltrates : Bool
  albumin_tenths_g_dl : Int
  respiratory_rate : Int
  age : Int
  confusion : Bool
  oxygen_saturation : Int
  arterial_ph_hundredths : Int
} derive(Eq, 
Debug)

#
SnapshotChange

source
pub(all) enum SnapshotChange {
  Increased(Int)
  Decreased(Int)
  Unchanged
  InstrumentChanged
} derive(Eq, 
Debug)

#
SofaInput

source
pub(all) struct SofaInput {
  pao2_fio2 : Int
  respiratory_support : Bool
  platelets : Int
  bilirubin_micromol : Int
  mean_arterial_pressure : Int
  vasopressor : VasopressorLevel
  gcs_total : Int
  creatinine_micromol : Int
  urine_ml_day : Int
} derive(Eq, 
Debug)

#
Spo2Scale

source
pub(all) enum Spo2Scale {
  Scale1
  Scale2
} derive(Eq, 
Debug)

#
StopBangInput

source
pub(all) struct StopBangInput {
  snoring : Bool
  tiredness : Bool
  observed_apnea : Bool
  hypertension : Bool
  bmi_over_35 : Bool
  age_over_50 : Bool
  neck_circumference_over_40_cm : Bool
  male : Bool
} derive(Eq, 
Debug)

#
ThresholdBand

source
pub(all) struct ThresholdBand {
  label : String
  minimum : Int
  maximum : Int
  points : Int
  explanation : String
} derive(Eq, 
Debug)

#
Timeline

source
pub(all) struct Timeline {
  observations : Array[Observation]
  last_timestamp_minutes : Int
} derive(Eq, 
Debug)

#
TimelineSummary

source
pub(all) struct TimelineSummary {
  observations : Int
  distinct_kinds : Int
  invalid_observations : Int
  earliest_timestamp : Int
  latest_timestamp : Int
  span_minutes : Int
} derive(Eq, 
Debug)

#
TimiInput

source
pub(all) struct TimiInput {
  age_65_or_more : Bool
  risk_factors : Int
  known_coronary_stenosis : Bool
  aspirin_last_7_days : Bool
  severe_angina : Bool
  st_deviation : Bool
  positive_biomarker : Bool
} derive(Eq, 
Debug)

#
TraceSummary

source
pub(all) struct TraceSummary {
  event_count : Int
  unique_instruments : Int
  first_timestamp : Int?
  last_timestamp : Int?
  invalid_event_count : Int
  source_labels : Array[String]
} derive(Eq, 
Debug)

#
Trend

source
pub(all) struct Trend {
  kind : ObservationKind
  first_value : Int
  latest_value : Int
  delta : Int
  samples : Int
  rising : Bool
  falling : Bool
  stable : Bool
} derive(Eq, 
Debug)

#
TriageBundle

source
pub(all) struct TriageBundle {
  news2 : ScoreReport
  qsofa : ScoreReport
  gcs : ScoreReport
  overall : Severity
  summary : String
  disclaimer : String
} derive(Eq, 
Debug)

#
TriageInput

source
pub(all) struct TriageInput {
  news2 : News2Input
  gcs : GcsInput
} derive(Eq, 
Debug)

#
ValidationError

source
pub(all) enum ValidationError {
  OutOfRange(field~ : String, value~ : Int, min~ : Int, max~ : Int)
  InvalidScale(field~ : String, value~ : Int)
} derive(Eq, 
Debug)

#
VasopressorLevel

source
pub(all) enum VasopressorLevel {
  None
  DopamineLow
  DopamineHigh
  NorepinephrineLow
  NorepinephrineHigh
} derive(Eq, 
Debug)

#
WellsDvtInput

source
pub(all) struct WellsDvtInput {
  active_cancer : Bool
  paralysis_or_immobilization : Bool
  bedridden_or_surgery : Bool
  tenderness_deep_veins : Bool
  entire_leg_swollen : Bool
  calf_swelling : Bool
  previous_dvt : Bool
  alternative_diagnosis : Bool
} derive(Eq, 
Debug)

#
WellsPeInput

source
pub(all) struct WellsPeInput {
  clinical_dvt_signs : Bool
  pe_most_likely : Bool
  heart_rate : Int
  surgery_or_immobilization : Bool
  previous_dvt_or_pe : Bool
  hemoptysis : Bool
  malignancy : Bool
} derive(Eq, 
Debug)

#
abcd2_age_points

source
fn abcd2_age_points(value : Int) -> Int

#
abcd2_clinical_points

source
fn abcd2_clinical_points(unilateral : Bool, speech_only : Bool) -> Int

#
abcd2_diabetes_points

source
fn abcd2_diabetes_points(value : Bool) -> Int

#
abcd2_duration_points

source
fn abcd2_duration_points(minutes : Int) -> Int

#
abcd2_pressure_points

source
fn abcd2_pressure_points(systolic : Int, diastolic : Int) -> Int

#
abcd2_severity

source
fn abcd2_severity(score : Int) -> Severity

#
aki_creatinine_stage

source
fn aki_creatinine_stage(input : AkiInput) -> Int

#
aki_severity

source
fn aki_severity(stage : Int) -> Severity

#
aki_stage

source
fn aki_stage(input : AkiInput) -> Int

#
aki_urine_stage

source
fn aki_urine_stage(input : AkiInput) -> Int

#
alvarado_score

source
fn alvarado_score(input : AlvaradoInput) -> Int

#
alvarado_severity

source
fn alvarado_severity(score : Int) -> Severity

#
apache_age_points

source
fn apache_age_points(value : Int) -> Int

#
apache_chronic_points

source
fn apache_chronic_points(value : Bool) -> Int

#
apache_creatinine_points

source
fn apache_creatinine_points(value : Int) -> Int

#
apache_heart_rate_points

source
fn apache_heart_rate_points(value : Int) -> Int

#
apache_hematocrit_points

source
fn apache_hematocrit_points(value : Int) -> Int

#
apache_ii_score

source
fn apache_ii_score(input : ApacheIiInput) -> Int

#
apache_ii_severity

source
fn apache_ii_severity(score : Int) -> Severity

#
apache_map_points

source
fn apache_map_points(value : Int) -> Int

#
apache_oxygenation_points

source
fn apache_oxygenation_points(value : Int, high_fio2 : Bool) -> Int

#
apache_ph_points

source
fn apache_ph_points(value : Int) -> Int

#
apache_potassium_points

source
fn apache_potassium_points(value : Int) -> Int

#
apache_respiratory_rate_points

source
fn apache_respiratory_rate_points(value : Int) -> Int

#
apache_sodium_points

source
fn apache_sodium_points(value : Int) -> Int

#
apache_temp_points

source
fn apache_temp_points(value : Int) -> Int

#
apache_white_cell_points

source
fn apache_white_cell_points(value : Int) -> Int

#
ariscat_age_points

source
fn ariscat_age_points(age : Int) -> Int

#
ariscat_anemia_points

source
fn ariscat_anemia_points(value : Bool) -> Int

#
ariscat_duration_points

source
fn ariscat_duration_points(minutes : Int) -> Int

#
ariscat_emergency_points

source
fn ariscat_emergency_points(value : Bool) -> Int

#
ariscat_incision_points

source
fn ariscat_incision_points(value : Int) -> Int

#
ariscat_infection_points

source
fn ariscat_infection_points(value : Bool) -> Int

#
ariscat_oxygen_points

source
fn ariscat_oxygen_points(value : Int) -> Int

#
ariscat_severity

source
fn ariscat_severity(score : Int) -> Severity

#
assessment_summary

source
fn assessment_summary(ledger : AssessmentLedger) -> AssessmentSummary

#
audit_event

source
fn audit_event(sequence : Int, event_type : String, instrument : String, report : ScoreReport, timestamp_minutes : Int, source : String, note : String) -> AuditEvent

#
audit_event_label

source
fn audit_event_label(event : AuditEvent) -> String

#
audit_event_labels

source
fn audit_event_labels(events : Array[AuditEvent]) -> Array[String]

#
audit_ordered

source
fn audit_ordered(left : AuditEvent, right : AuditEvent) -> Bool

#
bisap_age_points

source
fn bisap_age_points(value : Int) -> Int

#
bisap_bun_points

source
fn bisap_bun_points(value : Int) -> Int

#
bisap_effusion_points

source
fn bisap_effusion_points(value : Bool) -> Int

#
bisap_mentation_points

source
fn bisap_mentation_points(value : Bool) -> Int

#
bisap_score

source
fn bisap_score(input : BisapInput) -> Int

#
bisap_severity

source
fn bisap_severity(score : Int) -> Severity

#
bisap_sirs_points

source
fn bisap_sirs_points(value : Int) -> Int

#
bishop_consistency_points

source
fn bishop_consistency_points(value : Int) -> Int

#
bishop_dilation_points

source
fn bishop_dilation_points(value : Int) -> Int

#
bishop_effacement_points

source
fn bishop_effacement_points(value : Int) -> Int

#
bishop_position_points

source
fn bishop_position_points(value : Int) -> Int

#
bishop_score

source
fn bishop_score(input : BishopInput) -> Int

#
bishop_severity

source
fn bishop_severity(score : Int) -> Severity

#
bishop_station_points

source
fn bishop_station_points(value : Int) -> Int

#
bode_bmi_points

source
fn bode_bmi_points(value : Int) -> Int

#
bode_fev1_points

source
fn bode_fev1_points(value : Int) -> Int

#
bode_mrc_points

source
fn bode_mrc_points(value : Int) -> Int

#
bode_severity

source
fn bode_severity(score : Int) -> Severity

#
bode_walk_points

source
fn bode_walk_points(value : Int) -> Int

#
canadian_cspine_high_risk_count

source
fn canadian_cspine_high_risk_count(input : CanadianCspineInput) -> Int

#
canadian_cspine_low_risk_count

source
fn canadian_cspine_low_risk_count(input : CanadianCspineInput) -> Int

#
canadian_cspine_positive

source
fn canadian_cspine_positive(input : CanadianCspineInput) -> Bool

#
canadian_ct_head_high_risk_count

source
fn canadian_ct_head_high_risk_count(input : CanadianCtHeadInput) -> Int

#
canadian_ct_head_medium_risk_count

source
fn canadian_ct_head_medium_risk_count(input : CanadianCtHeadInput) -> Int

#
canadian_ct_head_positive

source
fn canadian_ct_head_positive(input : CanadianCtHeadInput) -> Bool

#
caprini_age_points

source
fn caprini_age_points(age : Int) -> Int

#
caprini_bool_points

source
fn caprini_bool_points(value : Bool, points : Int) -> Int

#
caprini_five_point_count

source
fn caprini_five_point_count(input : CapriniInput) -> Int

#
caprini_score

source
fn caprini_score(input : CapriniInput) -> Int

#
caprini_severity

source
fn caprini_severity(score : Int) -> Severity

#
caprini_three_point_count

source
fn caprini_three_point_count(input : CapriniInput) -> Int

#
caprini_two_point_count

source
fn caprini_two_point_count(input : CapriniInput) -> Int

#
cha2ds2_vasc_age_points

source
fn cha2ds2_vasc_age_points(value : Int) -> Int

#
cha2ds2_vasc_flag_points

source
fn cha2ds2_vasc_flag_points(value : Bool) -> Int

#
cha2ds2_vasc_severity

source
fn cha2ds2_vasc_severity(score : Int) -> Severity

#
cha2ds2_vasc_stroke_points

source
fn cha2ds2_vasc_stroke_points(value : Bool) -> Int

#
charlson_age_points

source
fn charlson_age_points(age : Int) -> Int

#
charlson_bool_points

source
fn charlson_bool_points(value : Bool, points : Int) -> Int

#
charlson_common_points

source
fn charlson_common_points(input : CharlsonInput) -> Int

#
charlson_score

source
fn charlson_score(input : CharlsonInput) -> Int

#
charlson_severe_points

source
fn charlson_severe_points(input : CharlsonInput) -> Int

#
charlson_severity

source
fn charlson_severity(score : Int) -> Severity

#
charlson_systemic_points

source
fn charlson_systemic_points(input : CharlsonInput) -> Int

#
charlson_vascular_points

source
fn charlson_vascular_points(input : CharlsonInput) -> Int

#
child_pugh_albumin_points

source
fn child_pugh_albumin_points(value : Int) -> Int

#
child_pugh_ascites_points

source
fn child_pugh_ascites_points(value : Int) -> Int

#
child_pugh_bilirubin_points

source
fn child_pugh_bilirubin_points(value : Int) -> Int

#
child_pugh_class

source
fn child_pugh_class(score : Int) -> String

#
child_pugh_encephalopathy_points

source
fn child_pugh_encephalopathy_points(value : Int) -> Int

#
child_pugh_inr_points

source
fn child_pugh_inr_points(value : Int) -> Int

#
child_pugh_severity

source
fn child_pugh_severity(score : Int) -> Severity

#
clamp

source
fn clamp(value : Int, low : Int, high : Int) -> Int

#
compare_metadata

source
fn compare_metadata(before : InstrumentMetadata?, after : InstrumentMetadata?, id : String) -> RegistryChange

#
compare_reports

source
fn compare_reports(left : ScoreReport, right : ScoreReport) -> ReportComparison

#
compare_snapshots

source
fn compare_snapshots(left : ScoreSnapshot, right : ScoreSnapshot) -> SnapshotChange

#
curbs65_age_points

source
fn curbs65_age_points(value : Int) -> Int

#
curbs65_confusion_points

source
fn curbs65_confusion_points(value : Bool) -> Int

#
curbs65_pressure_points

source
fn curbs65_pressure_points(systolic : Int, diastolic : Int) -> Int

#
curbs65_respiratory_points

source
fn curbs65_respiratory_points(value : Int) -> Int

#
curbs65_severity

source
fn curbs65_severity(score : Int) -> Severity

#
curbs65_urea_points

source
fn curbs65_urea_points(value : Int) -> Int

#
default_registry

source
fn default_registry() -> InstrumentRegistry

#
empty_ledger

source
fn empty_ledger() -> AssessmentLedger

#
empty_registry

source
fn empty_registry(revision : String) -> InstrumentRegistry

#
empty_timeline

source
fn empty_timeline() -> Timeline

#
escalation_rank

source
fn escalation_rank(tier : EscalationTier) -> Int

#
escalation_tier_label

source
fn escalation_tier_label(tier : EscalationTier) -> String

#
evaluate_pathway

source
fn evaluate_pathway(rules : Array[PathwayRule], reports : Array[ScoreReport]) -> PathwayDecision

#
evaluate_threshold

source
fn evaluate_threshold(rule_name : String, value : Int, bands : Array[ThresholdBand]) -> RuleEvaluation

#
evaluation_labels

source
fn evaluation_labels(evaluations : Array[RuleEvaluation]) -> Array[String]

#
evidence_status_label

source
fn evidence_status_label(status : EvidenceStatus) -> String

#
explanation

source
fn explanation(label : String, points : Int, detail : String) -> Explanation

#
explanation_label

source
fn explanation_label(item : Explanation) -> String

#
explanation_labels

source
fn explanation_labels(items : Array[Explanation]) -> Array[String]

#
four_score_severity

source
fn four_score_severity(score : Int) -> Severity

#
four_score_total

source
fn four_score_total(input : FourScoreInput) -> Int

#
gbs_bool_points

source
fn gbs_bool_points(value : Bool, points : Int) -> Int

#
gbs_bun_points

source
fn gbs_bun_points(value : Int) -> Int

#
gbs_female_hemoglobin_points

source
fn gbs_female_hemoglobin_points(value : Int) -> Int

#
gbs_hemoglobin_points

source
fn gbs_hemoglobin_points(value : Int, female : Bool) -> Int

#
gbs_male_hemoglobin_points

source
fn gbs_male_hemoglobin_points(value : Int) -> Int

#
gbs_pressure_points

source
fn gbs_pressure_points(value : Int) -> Int

#
gbs_pulse_points

source
fn gbs_pulse_points(value : Int) -> Int

#
gbs_severity

source
fn gbs_severity(score : Int) -> Severity

#
gcs_severity

source
fn gcs_severity(total : Int) -> Severity

#
gcs_total

source
fn gcs_total(input : GcsInput) -> Int

#
has_bled_severity

source
fn has_bled_severity(score : Int) -> Severity

#
heart_severity

source
fn heart_severity(score : Int) -> Severity

#
hestia_positive_points

source
fn hestia_positive_points(value : Bool) -> Int

#
hestia_severity

source
fn hestia_severity(score : Int) -> Severity

#
highest_concern_report

source
fn highest_concern_report(reports : Array[ScoreReport]) -> ScoreReport?

#
injury_severity_band

source
fn injury_severity_band(score : Int) -> Severity

#
injury_severity_score

source
fn injury_severity_score(input : InjurySeverityInput) -> Int

#
instrument_category_label

source
fn instrument_category_label(category : InstrumentCategory) -> String

#
instrument_present

source
fn instrument_present(reports : Array[ScoreReport], name : String) -> Bool

#
ledger_add

source
fn ledger_add(ledger : AssessmentLedger, item : ScoreSnapshot) -> AssessmentLedger

#
ledger_count_instrument

source
fn ledger_count_instrument(ledger : AssessmentLedger, instrument : String) -> Int

#
ledger_highest_severity

source
fn ledger_highest_severity(ledger : AssessmentLedger) -> Severity

#
ledger_instruments

source
fn ledger_instruments(ledger : AssessmentLedger) -> Array[String]

#
ledger_latest

source
fn ledger_latest(ledger : AssessmentLedger) -> ScoreSnapshot?

#
ledger_latest_instrument

source
fn ledger_latest_instrument(ledger : AssessmentLedger, instrument : String) -> ScoreSnapshot?

#
ledger_scores

source
fn ledger_scores(ledger : AssessmentLedger) -> Array[Int]

#
ledger_size

source
fn ledger_size(ledger : AssessmentLedger) -> Int

#
ledger_total_score

source
fn ledger_total_score(ledger : AssessmentLedger) -> Int

#
matched_evaluations

source
fn matched_evaluations(evaluations : Array[RuleEvaluation]) -> Array[RuleEvaluation]

#
max_pathway_severity

source
fn max_pathway_severity(left : Severity, right : Severity) -> Severity

#
max_tier

source
fn max_tier(left : EscalationTier, right : EscalationTier) -> EscalationTier

#
meld_component_points

source
fn meld_component_points(value : Int, low : Int, middle : Int, high : Int) -> Int

#
meld_na_score

source
fn meld_na_score(input : MeldNaInput) -> Int

#
meld_na_severity

source
fn meld_na_severity(score : Int) -> Severity

#
metadata

source
fn metadata(id : String, display_name : String, category : InstrumentCategory, unit : String, minimum : Int, maximum : Int, source_url : String, version : String, caution : String, keywords : Array[String]) -> InstrumentMetadata

#
metadata_same

source
fn metadata_same(left : InstrumentMetadata, right : InstrumentMetadata) -> Bool

#
mews_consciousness_points

source
fn mews_consciousness_points(value : Consciousness) -> Int

#
mews_heart_rate_points

source
fn mews_heart_rate_points(value : Int) -> Int

#
mews_respiratory_rate_points

source
fn mews_respiratory_rate_points(value : Int) -> Int

#
mews_severity

source
fn mews_severity(score : Int) -> Severity

#
mews_systolic_bp_points

source
fn mews_systolic_bp_points(value : Int) -> Int

#
mews_temperature_points

source
fn mews_temperature_points(value : Int) -> Int

#
news2_consciousness_points

source
fn news2_consciousness_points(consciousness : Consciousness) -> Int

#
news2_heart_rate_points

source
fn news2_heart_rate_points(heart_rate : Int) -> Int

#
news2_oxygen_saturation_points

source
fn news2_oxygen_saturation_points(saturation : Int, scale : Spo2Scale, supplemental_oxygen : Bool) -> Int

#
news2_respiratory_rate_points

source
fn news2_respiratory_rate_points(rate : Int) -> Int

#
news2_severity

source
fn news2_severity(score : Int, any_single_three : Bool) -> Severity

#
news2_supplemental_oxygen_points

source
fn news2_supplemental_oxygen_points(supplemental_oxygen : Bool) -> Int

#
news2_systolic_bp_points

source
fn news2_systolic_bp_points(systolic_bp : Int) -> Int

#
news2_temperature_points

source
fn news2_temperature_points(temperature_tenths_c : Int) -> Int

#
nexus_clears_cspine

source
fn nexus_clears_cspine(input : NexusCspineInput) -> Bool

#
nexus_positive_count

source
fn nexus_positive_count(input : NexusCspineInput) -> Int

#
nihss_severity

source
fn nihss_severity(score : Int) -> Severity

#
nihss_total

source
fn nihss_total(input : NihssInput) -> Int

#
observation

source
fn observation(kind : ObservationKind, value : Int, unit : MeasurementUnit, timestamp_minutes : Int, source : String) -> Observation

#
observation_age_minutes

source
fn observation_age_minutes(now : Int, item : Observation) -> Int

#
observation_delta

source
fn observation_delta(older : Observation, newer : Observation) -> Int

#
observation_is_fresh

source
fn observation_is_fresh(now : Int, item : Observation, window_minutes : Int) -> Bool

#
observation_is_ordered

source
fn observation_is_ordered(left : Observation, right : Observation) -> Bool

#
observation_issue_label

source
fn observation_issue_label(issue : ObservationIssue) -> String

#
observation_kind_label

source
fn observation_kind_label(kind : ObservationKind) -> String

#
observation_unit_label

source
fn observation_unit_label(unit : MeasurementUnit) -> String

#
ottawa_ankle_criterion_count

source
fn ottawa_ankle_criterion_count(input : OttawaAnkleInput) -> Int

#
ottawa_ankle_positive

source
fn ottawa_ankle_positive(input : OttawaAnkleInput) -> Bool

#
padua_score

source
fn padua_score(input : PaduaInput) -> Int

#
padua_severity

source
fn padua_severity(score : Int) -> Severity

#
pathway_decision_explanation

source
fn pathway_decision_explanation(tier : EscalationTier, evidence : EvidenceStatus, severity : Severity, matched_count : Int) -> String

#
pathway_missing_instruments

source
fn pathway_missing_instruments(rule : PathwayRule, reports : Array[ScoreReport]) -> Array[String]

#
pathway_rule_labels

source
fn pathway_rule_labels(rules : Array[PathwayRule]) -> Array[String]

#
pathway_rule_matches

source
fn pathway_rule_matches(rule : PathwayRule, reports : Array[ScoreReport]) -> Bool

#
pecarn_high_risk_count

source
fn pecarn_high_risk_count(input : PecarnHeadInput) -> Int

#
pecarn_intermediate_count

source
fn pecarn_intermediate_count(input : PecarnHeadInput) -> Int

#
pediatric_appendicitis_anorexia_points

source
fn pediatric_appendicitis_anorexia_points(value : Bool) -> Int

#
pediatric_appendicitis_cough_points

source
fn pediatric_appendicitis_cough_points(value : Bool) -> Int

#
pediatric_appendicitis_fever_points

source
fn pediatric_appendicitis_fever_points(value : Int) -> Int

#
pediatric_appendicitis_lab_points

source
fn pediatric_appendicitis_lab_points(leukocytosis : Bool, neutrophilia : Bool) -> Int

#
pediatric_appendicitis_migration_points

source
fn pediatric_appendicitis_migration_points(value : Bool) -> Int

#
pediatric_appendicitis_nausea_points

source
fn pediatric_appendicitis_nausea_points(value : Bool) -> Int

#
pediatric_appendicitis_score

source
fn pediatric_appendicitis_score(input : PediatricAppendicitisInput) -> Int

#
pediatric_appendicitis_severity

source
fn pediatric_appendicitis_severity(score : Int) -> Severity

#
pediatric_appendicitis_tenderness_points

source
fn pediatric_appendicitis_tenderness_points(value : Bool) -> Int

#
perc_negative

source
fn perc_negative(input : PercInput) -> Bool

#
perc_positive_count

source
fn perc_positive_count(input : PercInput) -> Int

#
pesi_severity

source
fn pesi_severity(score : Int) -> Severity

#
pews_behavior_points

source
fn pews_behavior_points(value : PewsBehavior) -> Int

#
pews_cardiovascular_points

source
fn pews_cardiovascular_points(value : PewsCardiovascular) -> Int

#
pews_nebulizer_points

source
fn pews_nebulizer_points(value : Int) -> Int

#
pews_oxygen_points

source
fn pews_oxygen_points(value : PewsOxygenSupport) -> Int

#
pews_respiratory_points

source
fn pews_respiratory_points(value : PewsRespiratory) -> Int

#
pews_severity

source
fn pews_severity(score : Int) -> Severity

#
preeclampsia_liver_points

source
fn preeclampsia_liver_points(ast : Int, alt : Int, pain : Bool) -> Int

#
preeclampsia_neurologic_points

source
fn preeclampsia_neurologic_points(headache : Bool, visual : Bool) -> Int

#
preeclampsia_other_points

source
fn preeclampsia_other_points(edema : Bool, growth : Bool) -> Int

#
preeclampsia_platelet_points

source
fn preeclampsia_platelet_points(value : Int) -> Int

#
preeclampsia_pressure_points

source
fn preeclampsia_pressure_points(systolic : Int, diastolic : Int) -> Int

#
preeclampsia_renal_points

source
fn preeclampsia_renal_points(value : Int) -> Int

#
preeclampsia_score

source
fn preeclampsia_score(input : PreeclampsiaInput) -> Int

#
preeclampsia_severity

source
fn preeclampsia_severity(score : Int) -> Severity

#
qcsi_flow_points

source
fn qcsi_flow_points(value : Int) -> Int

#
qcsi_oxygen_points

source
fn qcsi_oxygen_points(value : Int) -> Int

#
qcsi_respiratory_points

source
fn qcsi_respiratory_points(value : Int) -> Int

#
qcsi_severity

source
fn qcsi_severity(score : Int) -> Severity

#
qsofa_mentation_points

source
fn qsofa_mentation_points(gcs_total : Int) -> Int

#
qsofa_respiratory_rate_points

source
fn qsofa_respiratory_rate_points(respiratory_rate : Int) -> Int

#
qsofa_severity

source
fn qsofa_severity(score : Int) -> Severity

#
qsofa_systolic_bp_points

source
fn qsofa_systolic_bp_points(systolic_bp : Int) -> Int

#
quality_flag

source
fn quality_flag(field : String, quality : MeasurementQuality, message : String) -> QualityFlag

#
quality_for_int

source
fn quality_for_int(field : String, value : Int, min : Int, max : Int) -> QualityFlag

#
quality_for_news2

source
fn quality_for_news2(input : News2Input) -> Array[QualityFlag]

#
quality_for_optional

source
fn quality_for_optional(field : String, value : Int?) -> QualityFlag

#
quality_is_usable

source
fn quality_is_usable(flag : QualityFlag) -> Bool

#
quality_label

source
fn quality_label(quality : MeasurementQuality) -> String

#
ranson_48_hour_score

source
fn ranson_48_hour_score(input : RansonInput) -> Int

#
ranson_admission_score

source
fn ranson_admission_score(input : RansonInput) -> Int

#
ranson_score

source
fn ranson_score(input : RansonInput) -> Int

#
ranson_severity

source
fn ranson_severity(score : Int) -> Severity

#
rcri_flag_points

source
fn rcri_flag_points(value : Bool) -> Int

#
rcri_severity

source
fn rcri_severity(score : Int) -> Severity

#
registry_add

source
fn registry_add(registry : InstrumentRegistry, entry : InstrumentMetadata) -> InstrumentRegistry

#
registry_added

source
fn registry_added(changes : Array[RegistryChange]) -> Array[RegistryChange]

#
registry_category_count

source
fn registry_category_count(registry : InstrumentRegistry, category : InstrumentCategory) -> Int

#
registry_category_counts

source
fn registry_category_counts(registry : InstrumentRegistry) -> Array[String]

#
registry_category_entries

source
fn registry_category_entries(registry : InstrumentRegistry, category : InstrumentCategory) -> Array[InstrumentMetadata]

#
registry_change_kind_label

source
fn registry_change_kind_label(kind : RegistryChangeKind) -> String

#
registry_changes

source
fn registry_changes(before : InstrumentRegistry, after : InstrumentRegistry) -> Array[RegistryChange]

#
registry_contains

source
fn registry_contains(registry : InstrumentRegistry, id : String) -> Bool

#
registry_display_labels

source
fn registry_display_labels(registry : InstrumentRegistry) -> Array[String]

#
registry_filter_valid

source
fn registry_filter_valid(registry : InstrumentRegistry) -> InstrumentRegistry

#
registry_find

source
fn registry_find(registry : InstrumentRegistry, id : String) -> InstrumentMetadata?

#
registry_has_duplicate_ids

source
fn registry_has_duplicate_ids(registry : InstrumentRegistry) -> Bool

#
registry_ids

source
fn registry_ids(registry : InstrumentRegistry) -> Array[String]

#
registry_is_release_ready

source
fn registry_is_release_ready(registry : InstrumentRegistry) -> Bool

fn registry_keyword_search(registry : InstrumentRegistry, keyword : String) -> Array[InstrumentMetadata]

#
registry_merge

source
fn registry_merge(primary : InstrumentRegistry, additions : InstrumentRegistry) -> InstrumentRegistry

#
registry_removed

source
fn registry_removed(changes : Array[RegistryChange]) -> Array[RegistryChange]

#
registry_revision_label

source
fn registry_revision_label(registry : InstrumentRegistry) -> String

#
registry_select

source
fn registry_select(registry : InstrumentRegistry, ids : Array[String]) -> InstrumentRegistry

#
registry_size

source
fn registry_size(registry : InstrumentRegistry) -> Int

#
registry_unchanged

source
fn registry_unchanged(changes : Array[RegistryChange]) -> Array[RegistryChange]

#
registry_updated

source
fn registry_updated(changes : Array[RegistryChange]) -> Array[RegistryChange]

#
registry_validate

source
fn registry_validate(registry : InstrumentRegistry) -> Bool

#
render_change

source
fn render_change(left : ScoreSnapshot, right : ScoreSnapshot) -> String

#
render_explanation

source
fn render_explanation(item : Explanation) -> String

#
render_explanations

source
fn render_explanations(items : Array[Explanation]) -> String

#
render_ledger

source
fn render_ledger(ledger : AssessmentLedger) -> String

#
render_metadata

source
fn render_metadata(entry : InstrumentMetadata) -> String

#
render_pathway_decision

source
fn render_pathway_decision(decision : PathwayDecision) -> String

#
render_registry

source
fn render_registry(registry : InstrumentRegistry) -> String

#
render_registry_change

source
fn render_registry_change(change : RegistryChange) -> String

#
render_registry_changes

source
fn render_registry_changes(changes : Array[RegistryChange]) -> String

#
render_report

source
fn render_report(report : ScoreReport) -> String

#
render_report_comparison

source
fn render_report_comparison(comparison : ReportComparison) -> String

#
render_report_quality

source
fn render_report_quality(quality : ReportQuality) -> String

#
render_snapshot

source
fn render_snapshot(item : ScoreSnapshot) -> String

#
render_trace_summary

source
fn render_trace_summary(summary : TraceSummary) -> String

#
report

source
fn report(instrument : String, score : Int, severity : Severity, interpretation : String, explanations : Array[Explanation]) -> ScoreReport

#
report_average_delta_x100

source
fn report_average_delta_x100(left : Array[ScoreReport], right : Array[ScoreReport]) -> Int

#
report_average_score_x100

source
fn report_average_score_x100(reports : Array[ScoreReport]) -> Int

#
report_bundle_is_coherent

source
fn report_bundle_is_coherent(reports : Array[ScoreReport]) -> Bool

#
report_catalog

source
fn report_catalog(reports : Array[ScoreReport]) -> String

#
report_catalog_line

source
fn report_catalog_line(report : ScoreReport) -> String

#
report_comparison_label

source
fn report_comparison_label(comparison : ReportComparison) -> String

#
report_count_at_or_above

source
fn report_count_at_or_above(reports : Array[ScoreReport], severity : Severity) -> Int

#
report_csv_header

source
fn report_csv_header() -> String

#
report_csv_row

source
fn report_csv_row(report : ScoreReport) -> String

#
report_delta_label

source
fn report_delta_label(delta : Int) -> String

#
report_disclaimer_set

source
fn report_disclaimer_set(reports : Array[ScoreReport]) -> Array[String]

#
report_explanation_count

source
fn report_explanation_count(reports : Array[ScoreReport]) -> Int

#
report_explanation_total

source
fn report_explanation_total(report : ScoreReport) -> Int

#
report_find

source
fn report_find(reports : Array[ScoreReport], instrument : String) -> ScoreReport?

#
report_has_explanation

source
fn report_has_explanation(report : ScoreReport, label : String) -> Bool

#
report_has_severity

source
fn report_has_severity(reports : Array[ScoreReport], severity : Severity) -> Bool

#
report_header

source
fn report_header(report : ScoreReport) -> String

#
report_instrument_names

source
fn report_instrument_names(reports : Array[ScoreReport]) -> Array[String]

#
report_interpretations

source
fn report_interpretations(reports : Array[ScoreReport]) -> Array[String]

#
report_is_empty

source
fn report_is_empty(report : ScoreReport) -> Bool

#
report_is_more_concerning

source
fn report_is_more_concerning(left : ScoreReport, right : ScoreReport) -> Bool

#
report_max_score

source
fn report_max_score(reports : Array[ScoreReport]) -> Int

#
report_min_score

source
fn report_min_score(reports : Array[ScoreReport]) -> Int?

#
report_nonempty

source
fn report_nonempty(reports : Array[ScoreReport]) -> Array[ScoreReport]

#
report_points_for_label

source
fn report_points_for_label(report : ScoreReport, label : String) -> Int?

#
report_quality

source
fn report_quality(reports : Array[ScoreReport]) -> ReportQuality

#
report_quality_ready

source
fn report_quality_ready(quality : ReportQuality) -> Bool

#
report_range

source
fn report_range(reports : Array[ScoreReport]) -> Int

#
report_score_reconciles

source
fn report_score_reconciles(report : ScoreReport) -> Bool

#
report_score_reconciles_with_explanations

source
fn report_score_reconciles_with_explanations(report : ScoreReport, explanations : Array[Explanation]) -> Bool

#
report_score_sum

source
fn report_score_sum(reports : Array[ScoreReport]) -> Int

#
report_severity_rank

source
fn report_severity_rank(report : ScoreReport) -> Int

#
report_severity_vector

source
fn report_severity_vector(reports : Array[ScoreReport]) -> Array[String]

#
report_summary_line

source
fn report_summary_line(reports : Array[ScoreReport]) -> String

#
report_value_vector

source
fn report_value_vector(reports : Array[ScoreReport]) -> Array[Int]

#
reports_at_or_above

source
fn reports_at_or_above(reports : Array[ScoreReport], severity : Severity) -> Array[ScoreReport]

#
reports_csv

source
fn reports_csv(reports : Array[ScoreReport]) -> String

#
reports_have_invalid_score

source
fn reports_have_invalid_score(reports : Array[ScoreReport]) -> Bool

#
reports_highest_severity

source
fn reports_highest_severity(reports : Array[ScoreReport]) -> Severity

#
reports_render_lines

source
fn reports_render_lines(reports : Array[ScoreReport]) -> Array[String]

#
reports_with_severity

source
fn reports_with_severity(reports : Array[ScoreReport], severity : Severity) -> Array[ScoreReport]

#
revised_trauma_score

source
fn revised_trauma_score(input : RevisedTraumaInput) -> Int

#
revised_trauma_severity

source
fn revised_trauma_severity(score : Int) -> Severity

#
rox_severity

source
fn rox_severity(index_x100 : Int) -> Severity

#
rox_x100

source
fn rox_x100(input : RoxInput) -> Int

#
score_abcd2

source
fn score_abcd2(input : Abcd2Input) -> ScoreReport

#
score_aki

source
fn score_aki(input : AkiInput) -> ScoreReport

#
score_alvarado

source
fn score_alvarado(input : AlvaradoInput) -> ScoreReport

#
score_apache_ii

source
fn score_apache_ii(input : ApacheIiInput) -> ScoreReport

#
score_ariscat

source
fn score_ariscat(input : AriscatInput) -> ScoreReport

#
score_bisap

source
fn score_bisap(input : BisapInput) -> ScoreReport

#
score_bishop

source
fn score_bishop(input : BishopInput) -> ScoreReport

#
score_bode

source
fn score_bode(input : BodeInput) -> ScoreReport

#
score_canadian_cspine

source
fn score_canadian_cspine(input : CanadianCspineInput) -> ScoreReport

#
score_canadian_ct_head

source
fn score_canadian_ct_head(input : CanadianCtHeadInput) -> ScoreReport

#
score_caprini

source
fn score_caprini(input : CapriniInput) -> ScoreReport

#
score_cha2ds2_vasc

source
fn score_cha2ds2_vasc(input : Cha2ds2VascInput) -> ScoreReport

#
score_charlson

source
fn score_charlson(input : CharlsonInput) -> ScoreReport

#
score_child_pugh

source
fn score_child_pugh(input : ChildPughInput) -> ScoreReport

#
score_curbs65

source
fn score_curbs65(input : Curbs65Input) -> ScoreReport

#
score_four

source
fn score_four(input : FourScoreInput) -> ScoreReport

#
score_gcs

source
fn score_gcs(input : GcsInput) -> GcsReport

#
score_gcs_as_report

source
fn score_gcs_as_report(input : GcsInput) -> ScoreReport

#
score_glasgow_blatchford

source
fn score_glasgow_blatchford(input : GlasgowBlatchfordInput) -> ScoreReport

#
score_has_bled

source
fn score_has_bled(input : HasBledInput) -> ScoreReport

#
score_heart

source
fn score_heart(input : HeartInput) -> ScoreReport

#
score_hestia

source
fn score_hestia(input : HestiaInput) -> ScoreReport

#
score_injury_severity

source
fn score_injury_severity(input : InjurySeverityInput) -> ScoreReport

#
score_meld_na

source
fn score_meld_na(input : MeldNaInput) -> ScoreReport

#
score_mews

source
fn score_mews(input : MewsInput) -> ScoreReport

#
score_news2

source
fn score_news2(input : News2Input) -> ScoreReport

#
score_nexus_cspine

source
fn score_nexus_cspine(input : NexusCspineInput) -> ScoreReport

#
score_nihss

source
fn score_nihss(input : NihssInput) -> ScoreReport

#
score_ottawa_ankle

source
fn score_ottawa_ankle(input : OttawaAnkleInput) -> ScoreReport

#
score_padua

source
fn score_padua(input : PaduaInput) -> ScoreReport

#
score_pecarn_head

source
fn score_pecarn_head(input : PecarnHeadInput) -> ScoreReport

#
score_pediatric_appendicitis

source
fn score_pediatric_appendicitis(input : PediatricAppendicitisInput) -> ScoreReport

#
score_perc

source
fn score_perc(input : PercInput) -> ScoreReport

#
score_pesi

source
fn score_pesi(input : PesiInput) -> ScoreReport

#
score_pews

source
fn score_pews(input : PewsInput) -> ScoreReport

#
score_preeclampsia

source
fn score_preeclampsia(input : PreeclampsiaInput) -> ScoreReport

#
score_qcsi

source
fn score_qcsi(input : QcsiInput) -> ScoreReport

#
score_qsofa

source
fn score_qsofa(input : QsofaInput) -> ScoreReport

#
score_ranson

source
fn score_ranson(input : RansonInput) -> ScoreReport

#
score_rcri

source
fn score_rcri(input : RcriInput) -> ScoreReport

#
score_revised_trauma

source
fn score_revised_trauma(input : RevisedTraumaInput) -> ScoreReport

#
score_rox

source
fn score_rox(input : RoxInput) -> ScoreReport

#
score_shock_index

source
fn score_shock_index(input : ShockIndexInput) -> ScoreReport

#
score_sirs

source
fn score_sirs(input : SirsInput) -> ScoreReport

#
score_smart_cop

source
fn score_smart_cop(input : SmartCopInput) -> ScoreReport

#
score_sofa

source
fn score_sofa(input : SofaInput) -> ScoreReport

#
score_stop_bang

source
fn score_stop_bang(input : StopBangInput) -> ScoreReport

#
score_timi

source
fn score_timi(input : TimiInput) -> ScoreReport

#
score_triage

source
fn score_triage(input : TriageInput) -> TriageBundle

#
score_wells_dvt

source
fn score_wells_dvt(input : WellsDvtInput) -> ScoreReport

#
score_wells_pe

source
fn score_wells_pe(input : WellsPeInput) -> ScoreReport

#
severity_label

source
fn severity_label(severity : Severity) -> String

#
severity_rank

source
fn severity_rank(severity : Severity) -> Int

#
shock_index_severity

source
fn shock_index_severity(index_x100 : Int) -> Severity

#
shock_index_x100

source
fn shock_index_x100(input : ShockIndexInput) -> Int

#
sirs_heart_rate_points

source
fn sirs_heart_rate_points(value : Int) -> Int

#
sirs_respiratory_rate_points

source
fn sirs_respiratory_rate_points(value : Int) -> Int

#
sirs_severity

source
fn sirs_severity(score : Int) -> Severity

#
sirs_temperature_points

source
fn sirs_temperature_points(value : Int) -> Int

#
sirs_white_cell_points

source
fn sirs_white_cell_points(value : Int, immature_percent : Int) -> Int

#
smart_cop_age_points

source
fn smart_cop_age_points(value : Int) -> Int

#
smart_cop_albumin_points

source
fn smart_cop_albumin_points(value : Int) -> Int

#
smart_cop_confusion_points

source
fn smart_cop_confusion_points(value : Bool) -> Int

#
smart_cop_infiltrate_points

source
fn smart_cop_infiltrate_points(value : Bool) -> Int

#
smart_cop_oxygen_points

source
fn smart_cop_oxygen_points(value : Int) -> Int

#
smart_cop_ph_points

source
fn smart_cop_ph_points(value : Int) -> Int

#
smart_cop_pressure_points

source
fn smart_cop_pressure_points(value : Int) -> Int

#
smart_cop_respiration_points

source
fn smart_cop_respiration_points(value : Int, age : Int) -> Int

#
smart_cop_score

source
fn smart_cop_score(input : SmartCopInput) -> Int

#
smart_cop_severity

source
fn smart_cop_severity(score : Int) -> Severity

#
snapshot

source
fn snapshot(instrument : String, score : Int, severity : Severity, timestamp_minutes : Int, source : String) -> ScoreSnapshot

#
snapshot_age_minutes

source
fn snapshot_age_minutes(now : Int, item : ScoreSnapshot) -> Int

#
snapshot_change_amount

source
fn snapshot_change_amount(change : SnapshotChange) -> Int

#
snapshot_change_label

source
fn snapshot_change_label(change : SnapshotChange) -> String

#
snapshot_from_report

source
fn snapshot_from_report(report : ScoreReport, timestamp_minutes : Int, source : String) -> ScoreSnapshot

#
snapshot_is_fresh

source
fn snapshot_is_fresh(now : Int, item : ScoreSnapshot, window_minutes : Int) -> Bool

#
sofa_bilirubin_points

source
fn sofa_bilirubin_points(value : Int) -> Int

#
sofa_circulation_points

source
fn sofa_circulation_points(map : Int, pressor : VasopressorLevel) -> Int

#
sofa_gcs_points

source
fn sofa_gcs_points(value : Int) -> Int

#
sofa_platelet_points

source
fn sofa_platelet_points(value : Int) -> Int

#
sofa_renal_points

source
fn sofa_renal_points(creatinine : Int, urine : Int) -> Int

#
sofa_respiratory_points

source
fn sofa_respiratory_points(ratio : Int, support : Bool) -> Int

#
sofa_severity

source
fn sofa_severity(score : Int) -> Severity

#
sort_audit_events

source
fn sort_audit_events(events : Array[AuditEvent]) -> Array[AuditEvent]

#
stop_bang_score

source
fn stop_bang_score(input : StopBangInput) -> Int

#
stop_bang_severity

source
fn stop_bang_severity(score : Int) -> Severity

#
sum_evaluations

source
fn sum_evaluations(evaluations : Array[RuleEvaluation]) -> Int

#
summarize_quality

source
fn summarize_quality(flags : Array[QualityFlag]) -> QualitySummary

#
summarize_reports

source
fn summarize_reports(reports : Array[ScoreReport]) -> ReportSummary

#
threshold_band

source
fn threshold_band(label : String, minimum : Int, maximum : Int, points : Int, explanation : String) -> ThresholdBand

#
threshold_contains

source
fn threshold_contains(band : ThresholdBand, value : Int) -> Bool

#
threshold_find

source
fn threshold_find(bands : Array[ThresholdBand], value : Int) -> ThresholdBand?

#
threshold_labels

source
fn threshold_labels(bands : Array[ThresholdBand]) -> Array[String]

#
threshold_points

source
fn threshold_points(bands : Array[ThresholdBand], value : Int) -> Int?

#
timeline_add

source
fn timeline_add(timeline : Timeline, item : Observation) -> Timeline

#
timeline_count_of

source
fn timeline_count_of(timeline : Timeline, kind : ObservationKind) -> Int

#
timeline_latest

source
fn timeline_latest(timeline : Timeline) -> Observation?

#
timeline_latest_of

source
fn timeline_latest_of(timeline : Timeline, kind : ObservationKind) -> Observation?

#
timeline_length

source
fn timeline_length(timeline : Timeline) -> Int

#
timeline_summary

source
fn timeline_summary(timeline : Timeline) -> TimelineSummary

#
timeline_valid

source
fn timeline_valid(timeline : Timeline) -> Bool

#
timi_risk_factor_points

source
fn timi_risk_factor_points(value : Int) -> Int

#
timi_severity

source
fn timi_severity(score : Int) -> Severity

#
trace_summary

source
fn trace_summary(events : Array[AuditEvent]) -> TraceSummary

#
trauma_gcs_points

source
fn trauma_gcs_points(value : Int) -> Int

#
trauma_pressure_points

source
fn trauma_pressure_points(value : Int) -> Int

#
trauma_respiration_points

source
fn trauma_respiration_points(value : Int) -> Int

#
trend_direction

source
fn trend_direction(trend : Trend) -> String

#
trend_for

source
fn trend_for(timeline : Timeline, kind : ObservationKind) -> Trend?

#
triage_disclaimer

source
fn triage_disclaimer() -> String

#
validate_abcd2

source
fn validate_abcd2(input : Abcd2Input) -> ValidationError?

#
validate_aki

source
fn validate_aki(input : AkiInput) -> ValidationError?

#
validate_alvarado

source
fn validate_alvarado(input : AlvaradoInput) -> ValidationError?

#
validate_apache_ii

source
fn validate_apache_ii(input : ApacheIiInput) -> ValidationError?

#
validate_ariscat

source
fn validate_ariscat(input : AriscatInput) -> ValidationError?

#
validate_audit_event

source
fn validate_audit_event(event : AuditEvent) -> ValidationError?

#
validate_bisap

source
fn validate_bisap(input : BisapInput) -> ValidationError?

#
validate_bishop

source
fn validate_bishop(input : BishopInput) -> ValidationError?

#
validate_bode

source
fn validate_bode(input : BodeInput) -> ValidationError?

#
validate_bool_scale

source
fn validate_bool_scale(field : String, value : Int) -> ValidationError?

#
validate_canadian_cspine

source
fn validate_canadian_cspine(input : CanadianCspineInput) -> ValidationError?

#
validate_canadian_ct_head

source
fn validate_canadian_ct_head(input : CanadianCtHeadInput) -> ValidationError?

#
validate_caprini

source
fn validate_caprini(input : CapriniInput) -> ValidationError?

#
validate_cha2ds2_vasc

source
fn validate_cha2ds2_vasc(input : Cha2ds2VascInput) -> ValidationError?

#
validate_charlson

source
fn validate_charlson(input : CharlsonInput) -> ValidationError?

#
validate_child_pugh

source
fn validate_child_pugh(input : ChildPughInput) -> ValidationError?

#
validate_curbs65

source
fn validate_curbs65(input : Curbs65Input) -> ValidationError?

#
validate_four_score

source
fn validate_four_score(input : FourScoreInput) -> ValidationError?

#
validate_gcs

source
fn validate_gcs(input : GcsInput) -> ValidationError?

#
validate_glasgow_blatchford

source
fn validate_glasgow_blatchford(input : GlasgowBlatchfordInput) -> ValidationError?

#
validate_heart

source
fn validate_heart(input : HeartInput) -> ValidationError?

#
validate_injury_severity

source
fn validate_injury_severity(input : InjurySeverityInput) -> ValidationError?

#
validate_meld_na

source
fn validate_meld_na(input : MeldNaInput) -> ValidationError?

#
validate_metadata

source
fn validate_metadata(entry : InstrumentMetadata) -> Bool

#
validate_mews

source
fn validate_mews(input : MewsInput) -> ValidationError?

#
validate_news2

source
fn validate_news2(input : News2Input) -> ValidationError?

#
validate_nihss

source
fn validate_nihss(input : NihssInput) -> ValidationError?

#
validate_observation

source
fn validate_observation(item : Observation) -> ObservationIssue?

#
validate_padua

source
fn validate_padua(input : PaduaInput) -> ValidationError?

#
validate_pecarn_head

source
fn validate_pecarn_head(input : PecarnHeadInput) -> ValidationError?

#
validate_pediatric_appendicitis

source
fn validate_pediatric_appendicitis(input : PediatricAppendicitisInput) -> ValidationError?

#
validate_perc

source
fn validate_perc(input : PercInput) -> ValidationError?

#
validate_pesi

source
fn validate_pesi(input : PesiInput) -> ValidationError?

#
validate_pews

source
fn validate_pews(input : PewsInput) -> ValidationError?

#
validate_preeclampsia

source
fn validate_preeclampsia(input : PreeclampsiaInput) -> ValidationError?

#
validate_qcsi

source
fn validate_qcsi(input : QcsiInput) -> ValidationError?

#
validate_qsofa

source
fn validate_qsofa(input : QsofaInput) -> ValidationError?

#
validate_range

source
fn validate_range(field : String, value : Int, min : Int, max : Int) -> ValidationError?

#
validate_ranson

source
fn validate_ranson(input : RansonInput) -> ValidationError?

#
validate_revised_trauma

source
fn validate_revised_trauma(input : RevisedTraumaInput) -> ValidationError?

#
validate_rox

source
fn validate_rox(input : RoxInput) -> ValidationError?

#
validate_shock_index

source
fn validate_shock_index(input : ShockIndexInput) -> ValidationError?

#
validate_sirs

source
fn validate_sirs(input : SirsInput) -> ValidationError?

#
validate_smart_cop

source
fn validate_smart_cop(input : SmartCopInput) -> ValidationError?

#
validate_sofa

source
fn validate_sofa(input : SofaInput) -> ValidationError?

#
validate_timi

source
fn validate_timi(input : TimiInput) -> ValidationError?

#
validate_triage

source
fn validate_triage(input : TriageInput) -> ValidationError?

#
validate_wells_pe

source
fn validate_wells_pe(input : WellsPeInput) -> ValidationError?

#
validation_error_field

source
fn validation_error_field(err : ValidationError) -> String

#
validation_error_message

source
fn validation_error_message(err : ValidationError) -> String

#
wells_dvt_severity

source
fn wells_dvt_severity(score : Int) -> Severity

#
wells_pe_dvt_points

source
fn wells_pe_dvt_points(value : Bool) -> Int

#
wells_pe_hemoptysis_points

source
fn wells_pe_hemoptysis_points(value : Bool) -> Int

#
wells_pe_immobilization_points

source
fn wells_pe_immobilization_points(value : Bool) -> Int

#
wells_pe_likely_points

source
fn wells_pe_likely_points(value : Bool) -> Int

#
wells_pe_malignancy_points

source
fn wells_pe_malignancy_points(value : Bool) -> Int

#
wells_pe_previous_event_points

source
fn wells_pe_previous_event_points(value : Bool) -> Int

#
wells_pe_rate_points

source
fn wells_pe_rate_points(value : Int) -> Int

#
wells_pe_severity

source
fn wells_pe_severity(score : Int) -> Severity

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io