define "Initial Population":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days"

define "Denominator":
  "Initial Population"

define "Denominator Exclusions":
  "Encounter With Degenerative Neurological Disorder"
    union "Encounter With High Risk To Airway Head Neck And Thoracic Surgery"
    union "Encounter With Mechanical Ventilation That Starts More Than One Hour Prior To Start Of First OR Procedure"
    union "Encounter With Neuromuscular Disorder"
    union "Encounter With PaCO2 Greater Than 50 And Arterial pH Less Than 7.30 Within 48 Hours Prior To Start Of First OR Procedure"
    union "Encounter With PaO2 Less Than 50 Within 48 Hours Prior To Start Of First OR Procedure"
    union "Encounter With Principal Diagnosis Of Acute Respiratory Failure"
    union "Encounter With Diagnosis Of Acute Respiratory Failure Present On Admission"
    union "Encounter With Tracheostomy Present On Admission"
    union "Encounter With Tracheostomy Prior To Or On The Same Day Of First OR Procedure"

define "Numerator":
  "Encounter With Intubation Outside Of Procedural Area Within 30 Days Of End Of First OR Procedure"
    union "Encounter With Mechanical Ventilation Outside Of Procedural Area Within 30 Days Of End Of First OR Procedure And Preceded By Non Invasive Oxygen Therapy"
    union "Encounter With Extubation Outside Of Procedural Area Within 30 Days Of End Of First OR Procedure More Than 48 Hours After End Of Anesthesia"
    union "Encounter With Mechanical Ventilation Within 30 Days Of End Of First OR Procedure And Between 48 And 72 Hours After End Of OR Procedure And Not Preceded By Non Invasive Oxygen Therapy Or Anesthesia"

define "SDE Payer":
  [Coverage: type in "Payer Type"] Payer
    return {
      code: Payer.type,
      period: Payer.period
    }

define "SDE Race":
  Patient.race R
    return Tuple {
      codes: R.ombCategory union R.detailed,
      display: R.text
    }

define "SDE Sex":
  case
    when Patient.sex = '248153007' then "Male (finding)"
    when Patient.sex = '248152002' then "Female (finding)"
    else null
  end

define "SDE Ethnicity":
  Patient.ethnicity E
    return Tuple {
      codes: { E.ombCategory } union E.detailed,
      display: E.text
    }

/*
@description: Converts the given [Period](https://hl7.org/fhir/datatypes.html#Period)
value to a CQL DateTime Interval
@comment: If the start value of the given period is unspecified, the starting
boundary of the resulting interval will be open (meaning the start of the interval
is unknown, as opposed to interpreted as the beginning of time).
*/
define function ToInterval(period FHIR.Period):
    if period is null then
        null
    else
        if period."start" is null then
            Interval(period."start".value, period."end".value]
        else
            Interval[period."start".value, period."end".value]

/*
@description: Converts the given FHIR [CodeableConcept](https://hl7.org/fhir/datatypes.html#CodeableConcept) value to a CQL Concept.
*/
define function ToConcept(concept FHIR.CodeableConcept):
    if concept is null then
        null
    else
        System.Concept {
            codes: concept.coding C return ToCode(C),
            display: concept.text.value
        }

/*
@description: Converts the given FHIR [Coding](https://hl7.org/fhir/datatypes.html#Coding) value to a CQL Code.
*/
define function ToCode(coding FHIR.Coding):
    if coding is null then
        null
    else
        System.Code {
          code: coding.code.value,
          system: coding.system.value,
          version: coding.version.value,
          display: coding.display.value
        }

define function ToString(value uri): value.value

/*
@description: Returns true if the given reference is to the given resourceId
@comment: Returns true if the `resourceId` parameter exactly equals the tail of the given reference.
NOTE: This function assumes resources from the same source server.
*/
define fluent function references(reference Reference, resourceId String):
  resourceId = Last(Split(reference.reference, '/'))

/*
@description: Given an interval, return the starting point if the interval has a starting boundary specified,
otherwise, return the ending point
*/
define fluent function earliest(choice Choice<DateTime, Quantity, Interval<DateTime>, Interval<Quantity>> ):
  (choice.toInterval()) period
    return
      if (period."hasStart"()) then start of period
      else end of period

/*
@description: Given an interval, return true if the interval has a starting boundary specified
(i.e. the start of the interval is not null and not the minimum DateTime value)
*/
define fluent function hasStart(period Interval<DateTime> ):
  not ( start of period is null
      or start of period = minimum DateTime
  )

/*
@description: Returns true if any of the given references are to the given resource
@comment: Returns true if the `id` element of the given resource exactly equals the tail of any of the given references.
NOTE: This function assumes resources from the same source server.
*/
define fluent function references(references List<Reference>, resource Resource):
  exists (references R where R.references(resource))

/*
@description: Returns true if the given reference is to the given resource
@comment: Returns true if the `id` element of the given resource exactly equals the tail of the given reference.
NOTE: This function assumes resources from the same source server.
*/
define fluent function references(reference Reference, resource Resource):
  resource.id = Last(Split(reference.reference, '/'))

/*
@description: Normalizes a value that is a choice of timing-valued types to an equivalent interval
@comment: Normalizes a choice type of DateTime, Quanitty, Interval<DateTime>, or Interval<Quantity> types
to an equivalent interval. This selection of choice types is a superset of the majority of choice types that are used as possible
representations for timing-valued elements in QICore, allowing this function to be used across any resource.
The input can be provided as a DateTime, Quantity, Interval<DateTime> or Interval<Quantity>.
The intent of this function is to provide a clear and concise mechanism to treat single
elements that have multiple possible representations as intervals so that logic doesn't have to account
for the variability. More complex calculations (such as medication request period or dispense period
calculation) need specific guidance and consideration. That guidance may make use of this function, but
the focus of this function is on single element calculations where the semantics are unambiguous.
If the input is a DateTime, the result a DateTime Interval beginning and ending on that DateTime.
If the input is a Quantity, the quantity is expected to be a calendar-duration interpreted as an Age,
and the result is a DateTime Interval beginning on the Date the patient turned that age and ending immediately before one year later.
If the input is a DateTime Interval, the result is the input.
If the input is a Quantity Interval, the quantities are expected to be calendar-durations interpreted as an Age, and the result
is a DateTime Interval beginning on the date the patient turned the age given as the start of the quantity interval, and ending
immediately before one year later than the date the patient turned the age given as the end of the quantity interval.
If the input is a Timing, an error will be thrown indicating that Timing calculations are not implemented. Any other input will reslt in a null DateTime Interval
*/
define fluent function toInterval(choice Choice<DateTime, Quantity, Interval<DateTime>, Interval<Quantity>, Timing>):
  case
	  when choice is DateTime then
    	Interval[choice as DateTime, choice as DateTime]
		when choice is Interval<DateTime> then
  		choice as Interval<DateTime>
		when choice is Quantity then
		  Interval[Patient.birthDate + (choice as Quantity),
			  Patient.birthDate + (choice as Quantity) + 1 year)
		when choice is Interval<Quantity> then
		  Interval[Patient.birthDate + (choice.low as Quantity),
			  Patient.birthDate + (choice.high as Quantity) + 1 year)
		when choice is Timing then
      Message(null, true, 'NOT_IMPLEMENTED', 'Error', 'Calculation of an interval from a Timing value is not supported') as Interval<DateTime>
		else
			null as Interval<DateTime>
	end

/*
@description: Given an interval, returns the ending point if the interval has an ending boundary specified,
otherwise, returns the starting point
*/
define fluent function latest(choice Choice<DateTime, Quantity, Interval<DateTime>, Interval<Quantity>> ):
  (choice.toInterval()) period
    return
      if (period."hasEnd"()) then end of period
      else start of period

/*
@description: Given an interval, returns true if the interval has an ending boundary specified
(i.e. the end of the interval is not null and not the maximum DateTime value)
*/
define fluent function hasEnd(period Interval<DateTime> ):
  not (
    end of period is null
      or end of period = maximum DateTime
  )

/*
@description: Returns true if the given code is in the given codeList
@comment: Returns true if the `code` is equivalent to any of the codes in the given `codeList`, false otherwise.
*/
define fluent function includesCode(codeList List<Concept>, code Code):
  exists (codeList C where C ~ code)

/*
@description: Hospitalization with Observation and Outpatient Surgery Service returns the total interval from the start of any immediately prior emergency department visit, outpatient surgery visit or observation visit to the discharge of the given encounter.
*/
define fluent function hospitalizationWithObservationAndOutpatientSurgeryService(TheEncounter "Encounter" ):
  TheEncounter Visit
	  let ObsVisit: Last([Encounter: "Observation Services"] LastObs
		  	where LastObs.status = 'finished'
          and LastObs.period ends 1 hour or less on or before start of Visit.period
			  sort by	end of period
    	),
    	VisitStart: Coalesce(start of ObsVisit.period, start of Visit.period),
    	EDVisit: Last([Encounter: "Emergency Department Visit"] LastED
			  where LastED.status = 'finished'
          and LastED.period ends 1 hour or less on or before VisitStart
			  sort by	end of period
    	),
    	VisitStartWithED: Coalesce(start of EDVisit.period, VisitStart),
    	OutpatientSurgeryVisit: Last([Encounter: "Outpatient Surgery Service"] LastSurgeryOP
			  where LastSurgeryOP.period ends 1 hour or less on or before VisitStartWithED
			  sort by	end of period
    	)
  	return Interval[Coalesce(start of OutpatientSurgeryVisit.period, VisitStartWithED), end of Visit.period]

/*
@description: Hospitalization with Observation returns the total interval from the start of any immediately prior emergency department visit through the observation visit to the discharge of the given encounter
*/
define fluent function hospitalizationWithObservation(TheEncounter Encounter ):
  TheEncounter Visit
  		let ObsVisit: Last([Encounter: "Observation Services"] LastObs
  				where LastObs.status = 'finished'
            and LastObs.period ends 1 hour or less on or before start of Visit.period
  				sort by end of period
  			),
  			VisitStart: Coalesce(start of ObsVisit.period, start of Visit.period),
  			EDVisit: Last([Encounter: "Emergency Department Visit"] LastED
  				where LastED.status = 'finished'
            and LastED.period ends 1 hour or less on or before VisitStart
  				sort by end of period
  			)
  		return Interval[Coalesce(start of EDVisit.period, VisitStart), end of Visit.period]

/*
 @description: Returns the condition that is specified as the principal diagnosis for the encounter and has a code in the given valueSet.
 @comment: See the QICore 6 Authoring Patterns discussion on [Principal Diagnosis and Present on Admission](https://github.com/cqframework/CQL-Formatting-and-Usage-Wiki/wiki/Authoring-Patterns-QICore-v6.0.0#conditions-present-on-admission-and-principal-diagnoses) for more information
 */
 define fluent function hasPrincipalDiagnosisOf(encounter Encounter, valueSet ValueSet):
   (encounter.principalDiagnosis()) PD
     return PD.diagnosis in valueSet
       or PD.diagnosis.getCondition().code in valueSet

/*
@description: Returns the claim diagnosis element that is specified as the principal diagnosis for the encounter
 @comment: See the QICore 6 Authoring Patterns discussion on [Principal Diagnosis and Present on Admission](https://github.com/cqframework/CQL-Formatting-and-Usage-Wiki/wiki/Authoring-Patterns-QICore-v6.0.0#conditions-present-on-admission-and-principal-diagnoses) for more information
*/
define fluent function principalDiagnosis(encounter Encounter):
singleton from (
     (encounter.claimDiagnosis()) CD
       where CD.type.includesCode("Principal Diagnosis")
   )

/*
@description: Returns the claim diagnosis elements for the given encounter
@comment: See the QICore 6 Authoring Patterns discussion on [Principal Diagnosis and Present on Admission](https://github.com/cqframework/CQL-Formatting-and-Usage-Wiki/wiki/Authoring-Patterns-QICore-v6.0.0#conditions-present-on-admission-and-principal-diagnoses) for more information
*/
define fluent function claimDiagnosis(encounter Encounter):
  encounter E
    let 
      claim: ([Claim] C where C.status = 'active' and C.use = 'claim' and exists (C.item I where I.encounter.references(E))),
      claimItem: (claim.item I where I.encounter.references(E))
    return claim.diagnosis D where D.sequence in claimItem.diagnosisSequence

/*
@description: Returns the Condition resource for the given reference
*/
define fluent function getCondition(reference Reference):
  singleton from (([ConditionEncounterDiagnosis] union [ConditionProblemsHealthConcerns]) C where reference.references(C.id))

/*
 @description: Returns true if the given diagnosis is present on admission, based on the given poaValueSet
 @comment: See the QICore 6 Authoring Patterns discussion on [Principal Diagnosis and Present on Admission](https://github.com/cqframework/CQL-Formatting-and-Usage-Wiki/wiki/Authoring-Patterns-QICore-v6.0.0#conditions-present-on-admission-and-principal-diagnoses) for more information
 */
 define fluent function isDiagnosisPresentOnAdmission(encounter Encounter, diagnosisValueSet ValueSet, poaValueSet ValueSet):
   exists (
     (encounter.claimDiagnosis()) CD
       where CD.onAdmission in poaValueSet
         and (
           CD.diagnosis in diagnosisValueSet
             or CD.diagnosis.getCondition().code in diagnosisValueSet
         )
   )

define "Elective Inpatient Encounter With Age 18 And Older Without ED Visit":
  ["Encounter": "Elective Inpatient Encounter"] ElectiveEncounter
    where ElectiveEncounter.status = 'finished'
      and ElectiveEncounter.period ends during day of "Measurement Period"
      and ElectiveEncounter.priority is not null implies ElectiveEncounter.priority ~ "Elective (qualifier value)"
      and AgeInYearsAt(date from start of ElectiveEncounter.period) >= 18
      and not exists ( ["Encounter": "Emergency Department Visit"] EDVisit
          where EDVisit.status = 'finished'
            and EDVisit.period ends 1 hour or less before or on start of ElectiveEncounter.period
      )

define "Elective Inpatient Encounter With Age And Without Obstetrical Condition":
  "Elective Inpatient Encounter With Age 18 And Older Without ED Visit" ElectiveEncounter
    where not ( ElectiveEncounter.reasonCode in "Obstetrical Or Pregnancy Related Conditions"
        or ElectiveEncounter.encounterReason ( ).code in "Obstetrical Or Pregnancy Related Conditions"
    )

define "Elective Inpatient Encounter With OR Procedure Within 3 Days":
  "Elective Inpatient Encounter With Age And Without Obstetrical Condition" ElectiveEncounter
    with ["Procedure": "General And Neuraxial Anesthesia"] SurgeryWithAnesthesia
      such that SurgeryWithAnesthesia.status = 'completed'
        and SurgeryWithAnesthesia.performed.earliest ( ) during ElectiveEncounter.hospitalizationWithObservationAndOutpatientSurgeryService ( )
        and SurgeryWithAnesthesia.performed.earliest ( ) 3 days or less after start of ElectiveEncounter.hospitalizationWithObservationAndOutpatientSurgeryService ( )

define "Initial Population":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days"

define "Risk Variable First Respiratory Rate In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstRespiratoryRate: QualifyingEncounter.firstRespiratoryRate ( )
    }

define "Risk Variable First Albumin In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstAlbumin: QualifyingEncounter.firstAlbumin ( )
    }

define "Risk Variable First Arterial pH In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstArterialpH: QualifyingEncounter.firstArterialpH ( )
    }

define "Risk Variable First Body Temperature In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstBodyTemp: QualifyingEncounter.firstBodyTemperature ( )
    }

define "Risk Variable First Carbon Dioxide In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstCarbonDioxide: QualifyingEncounter.firstCarbonDioxide ( )
    }

define "Risk Variable First Hematocrit In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstHematocrit: QualifyingEncounter.firstHematocrit ( )
    }

define "Risk Variable First Heart Rate In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstHeartRate: QualifyingEncounter.firstHeartRate ( )
    }

define "Risk Variable First BMI":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstBMI: QualifyingEncounter.firstBMI ( )
    }

define "Risk Variable First Hemoglobin In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstHemoglobin: QualifyingEncounter.firstHemoglobin ( )
    }

define "Risk Variable All Encounter Diagnoses With POA Indication":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      diagnoses: QualifyingEncounter.claimDiagnosesWithPOA ( )
    }

define "Risk Variable First Sodium In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstSodium: QualifyingEncounter.firstSodium ( )
    }

define "SDE Payer":
  SDE."SDE Payer"

define "Risk Variable First Creatinine In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstCreatinine: QualifyingEncounter.firstCreatinine ( )
    }

define "Risk Variable First White Blood Cell Count In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstWBCcount: QualifyingEncounter.firstWhiteBloodCellCount ( )
    }

define "Risk Variable ASA Physical Status Class":
  ["ObservationScreeningAssessment": "American society of anesthesiologists morbidity state"] ASAclass
    with "Initial Population" QualifyingEncounter
      such that ASAclass.status in { 'final', 'amended', 'corrected' }
        and ASAclass.startsDuringHospitalization ( QualifyingEncounter )
        and ASAclass.value as Concept in "ASA Physical Status Class"
    return ASAclass.value as Concept

define "Risk Variable Principal Procedure":
  from
    ["Procedure"] TheProcedure,
    "Initial Population" QualifyingEncounter
    where TheProcedure.status = 'completed'
      and TheProcedure.rank ( QualifyingEncounter ) is not null
      and TheProcedure.startsDuringHospitalization ( QualifyingEncounter )
    return Tuple {
      encounterId: QualifyingEncounter.id,
      procedureId: TheProcedure.id,
      procedureCode: TheProcedure.code,
      procedureRank: TheProcedure.rank ( QualifyingEncounter ),
      procedureTime: TheProcedure.performed.toInterval ( )
    }

define "Risk Variable Body Mass Index (BMI)":
  ["USCoreBMIProfile"] BMI
    with "Initial Population" InpatientEncounter
      such that BMI.effective.toInterval ( ) starts during InpatientEncounter.hospitalizationWithObservation ( )
        and BMI.value is not null
        and BMI.status in { 'final', 'amended', 'corrected' }
    return BMI.value as Quantity

define "Risk Variable First Bicarbonate In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstBicarbonate: QualifyingEncounter.firstBicarbonate ( )
    }

define "Risk Variable First Bilirubin In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstBilirubin: QualifyingEncounter.firstBilirubin ( )
    }

define "Qualifying Systolic Blood Pressure Reading":
  ["USCoreBloodPressureProfile"] BloodPressure
    where BloodPressure.effective.earliest ( ) during day of "Measurement Period"

define "Risk Variable First Systolic Blood Pressure In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstSystolic: QualifyingEncounter.firstSystolicBloodPressure ( )
    }

define "Risk Variable First Oxygen In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstOxygen: QualifyingEncounter.firstOxygen ( )
    }

define "Risk Variable First Leukocyte Count In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstLeukocyte: QualifyingEncounter.firstLeukocyte ( )
    }

define "SDE Race":
  SDE."SDE Race"

define "SDE Sex":
  SDE."SDE Sex"

define "Anesthesia Procedure List":
  ["Procedure": "General And Neuraxial Anesthesia"] AnesthesiaProcedures
    where AnesthesiaProcedures.performed.latest ( ) during day of "Measurement Period"

define "General Anesthesia And MAC":
  ["Procedure": "Anesthesia Requiring Monitored Care"] MAC
    union ["Procedure": "General And Neuraxial Anesthesia"]

define "Intubation During General Anesthesia And MAC":
  from
    "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery,
    ["Procedure": "Intubation"] ProceduralIntubation,
    "General Anesthesia And MAC" Anesthesia
    where ProceduralIntubation.status = 'completed'
      and ProceduralIntubation.startsDuringHospitalization ( EncounterWithSurgery )
      and ProceduralIntubation.performed.toInterval ( ) starts during Anesthesia.performed.toInterval ( )
    return ProceduralIntubation

define "Encounter With Intubation Outside Of Procedural Area Within 30 Days Of End Of First OR Procedure":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery
    with ["Procedure": "Intubation"] EndotrachealTubeIn
      such that EndotrachealTubeIn.status = 'completed'
        and EndotrachealTubeIn.starts30DaysOrLessAfterFirstAnesthesia ( EncounterWithSurgery )
        and EndotrachealTubeIn.startsDuringHospitalization ( EncounterWithSurgery )
        and EndotrachealTubeIn.performed.toInterval ( ) starts after end of EndotrachealTubeIn.latestGeneralAnesthesiaOrMAC ( ).performed.toInterval ( )
        and EncounterWithSurgery.isNotAtProceduralHospitalLocationDuring ( EndotrachealTubeIn.performed.toInterval ( ) )
        and not ( "Intubation During General Anesthesia And MAC".id contains EndotrachealTubeIn.id )

define "Noninvasive Oxygen Therapy":
  ( ["Procedure": "Non Invasive Oxygen Therapy By Nasal Cannula Or Mask"] P
      where P.status = 'completed'
  )
    union ( ["LaboratoryResultObservation": "Non Invasive Oxygen Therapy"] O
        where O.status in { 'final', 'amended', 'corrected' }
    )

define "Encounter With Mechanical Ventilation Outside Of Procedural Area Within 30 Days Of End Of First OR Procedure And Preceded By Non Invasive Oxygen Therapy":
  from
    "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery,
    ["Procedure": "Mechanical Ventilation"] Ventilation,
    "Noninvasive Oxygen Therapy" OxygenSupport
    let VentilationInterval: Ventilation.performed.toInterval ( ),
    LatestAnesthesiaInterval: Ventilation.latestGeneralAnesthesiaOrMAC ( ).performed.toInterval ( )
    where Ventilation.status = 'completed'
      and Ventilation.starts30DaysOrLessAfterFirstAnesthesia ( EncounterWithSurgery )
      and Ventilation.startsDuringHospitalization ( EncounterWithSurgery )
      and VentilationInterval starts after end of LatestAnesthesiaInterval
      and OxygenSupport.interval ( ) starts during Interval[end of LatestAnesthesiaInterval, start of VentilationInterval]
      and EncounterWithSurgery.isNotAtProceduralHospitalLocationDuring ( VentilationInterval )
    return EncounterWithSurgery

define "Extubation With Preceding Noninvasive Oxygen":
  from
    "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery,
    ["Procedure": "Removal of endotracheal tube (procedure)"] Extubation,
    "Noninvasive Oxygen Therapy" OxygenSupport
    let LatestAnesthesia: Extubation.latestGeneralAnesthesiaOrMAC ( )
    where Extubation.status = 'completed'
      and Extubation.startsDuringHospitalization ( EncounterWithSurgery )
      and Extubation.performed.toInterval ( ) starts after LatestAnesthesia.performed.toInterval ( )
      and OxygenSupport.interval ( ) starts during Interval[end of LatestAnesthesia.performed.toInterval ( ), start of Extubation.performed.toInterval ( )]
    return Extubation

define "Extubation During General Anesthesia":
  from
    "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery,
    ["Procedure": "Removal of endotracheal tube (procedure)"] Extubation,
    "General Anesthesia And MAC" Anesthesia
    where Extubation.status = 'completed'
      and Extubation.startsDuringHospitalization ( EncounterWithSurgery )
      and Extubation.performed.toInterval ( ) starts during Anesthesia.performed.toInterval ( )
    return Extubation

define "Encounter With Extubation Outside Of Procedural Area Within 30 Days Of End Of First OR Procedure More Than 48 Hours After End Of Anesthesia":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery
    with ["Procedure": "Removal of endotracheal tube (procedure)"] Extubation
      such that Extubation.status = 'completed'
        and Extubation.isDuringHospitalization ( EncounterWithSurgery )
        and Extubation.starts30DaysOrLessAfterFirstAnesthesia ( EncounterWithSurgery )
        and Extubation.performed.toInterval ( ) starts more than 48 hours after end of Extubation.latestGeneralAnesthesiaOrMAC ( ).performed.toInterval ( )
        and not ( ( "Extubation With Preceding Noninvasive Oxygen".id contains Extubation.id )
            and not ( "Extubation During General Anesthesia".id contains Extubation.id )
        )
        and EncounterWithSurgery.isNotAtProceduralHospitalLocation ( )

define "Encounter With Mechanical Ventilation Within 30 Days Of End Of First OR Procedure And Between 48 And 72 Hours After End Of OR Procedure And Not Preceded By Non Invasive Oxygen Therapy Or Anesthesia":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery
    with ["Procedure": "Mechanical Ventilation"] Ventilation
      such that Ventilation.status = 'completed'
        and Ventilation.performed.toInterval ( ) starts 48 hours or more after end of Ventilation.latestGeneralAnesthesiaOrMAC ( ).performed.toInterval ( )
        and Ventilation.performed.toInterval ( ) starts 72 hours or less after end of Ventilation.latestGeneralAnesthesiaOrMAC ( ).performed.toInterval ( )
        and Ventilation.starts30DaysOrLessAfterFirstAnesthesia ( EncounterWithSurgery )
        and Ventilation.startsDuringHospitalization ( EncounterWithSurgery )
        and not ( "Encounter With Mechanical Ventilation Outside Of Procedural Area Within 30 Days Of End Of First OR Procedure And Preceded By Non Invasive Oxygen Therapy".id contains EncounterWithSurgery.id )
        and EncounterWithSurgery.isNotAtProceduralHospitalLocation ( )

define "Numerator":
  "Encounter With Intubation Outside Of Procedural Area Within 30 Days Of End Of First OR Procedure"
    union "Encounter With Mechanical Ventilation Outside Of Procedural Area Within 30 Days Of End Of First OR Procedure And Preceded By Non Invasive Oxygen Therapy"
    union "Encounter With Extubation Outside Of Procedural Area Within 30 Days Of End Of First OR Procedure More Than 48 Hours After End Of Anesthesia"
    union "Encounter With Mechanical Ventilation Within 30 Days Of End Of First OR Procedure And Between 48 And 72 Hours After End Of OR Procedure And Not Preceded By Non Invasive Oxygen Therapy Or Anesthesia"

define "Denominator":
  "Initial Population"

define "Risk Variable Encounter Procedures":
  from
    ["Procedure"] TheProcedure,
    "Initial Population" QualifyingEncounter
    where TheProcedure.status = 'completed'
      and TheProcedure.startsDuringHospitalization ( QualifyingEncounter )
    return {
      encounterId: QualifyingEncounter.id,
      procedureId: TheProcedure.id,
      procedureCode: TheProcedure.code,
      procedureRank: TheProcedure.rank ( QualifyingEncounter ),
      procedureTime: TheProcedure.performed.toInterval ( )
    }

define "Risk Variable First Blood Urea Nitrogen In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstBUN: QualifyingEncounter.firstBloodUreaNitrogen ( )
    }

define "SDE Ethnicity":
  SDE."SDE Ethnicity"

define "Encounter With Degenerative Neurological Disorder":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery
    where EncounterWithSurgery.reasonCode in "Degenerative Neurological Disorder"
      or EncounterWithSurgery.encounterReason ( ).code in "Degenerative Neurological Disorder"

define "Encounter With High Risk To Airway Head Neck And Thoracic Surgery":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery
    with ["Procedure": "Head, Neck, And Thoracic Surgeries With High Risk Airway Compromise"] HeadNeckProcedures
      such that HeadNeckProcedures.status = 'completed'
        and HeadNeckProcedures.startsDuringHospitalization ( EncounterWithSurgery )

define "Encounter With Mechanical Ventilation That Starts More Than One Hour Prior To Start Of First OR Procedure":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery
    with ["Procedure": "Mechanical Ventilation"] Ventilation
      such that Ventilation.status = 'completed'
        and Ventilation.performed.toInterval ( ) starts more than 1 hour before start of EncounterWithSurgery.firstAnesthesiaDuringHospitalization ( ).performed.toInterval ( )
        and Ventilation.startsDuringHospitalization ( EncounterWithSurgery )

define "Encounter With Neuromuscular Disorder":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery
    where EncounterWithSurgery.reasonCode in "Neuromuscular Disorder"
      or EncounterWithSurgery.encounterReason ( ).code in "Neuromuscular Disorder"

define "Encounter With PaCO2 Greater Than 50 And Arterial pH Less Than 7.30 Within 48 Hours Prior To Start Of First OR Procedure":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery
    let FirstProcedureTime: EncounterWithSurgery.firstAnesthesiaDuringHospitalization ( ).performed.toInterval ( )
    with ["LaboratoryResultObservation": "Carbon Dioxide Partial Pressure In Arterial Blood"] CarbonDioxide
      such that CarbonDioxide.status in { 'final', 'amended', 'corrected' }
        and CarbonDioxide.effective.toInterval ( ) starts 48 hours or less before start of FirstProcedureTime
        and CarbonDioxide.value as Quantity > 50 'mm[Hg]'
    with ["LaboratoryResultObservation": "Arterial Blood pH"] BloodpH
      such that BloodpH.status in { 'final', 'amended', 'corrected' }
        and BloodpH.effective.toInterval ( ) starts 48 hours or less before start of FirstProcedureTime
        and BloodpH.value as Quantity < 7.30 '[pH]'

define "Encounter With PaO2 Less Than 50 Within 48 Hours Prior To Start Of First OR Procedure":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery
    let FirstProcedure: EncounterWithSurgery.firstAnesthesiaDuringHospitalization ( )
    with ["LaboratoryResultObservation": "Oxygen Partial Pressure In Arterial Blood"] Oxygen
      such that Oxygen.status in { 'final', 'amended', 'corrected' }
        and Oxygen.effective.toInterval ( ) starts 48 hours or less before start of FirstProcedure.performed.toInterval ( )
        and Oxygen.value as Quantity < 50 'mm[Hg]'

define "Encounter With Principal Diagnosis Of Acute Respiratory Failure":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery
    where EncounterWithSurgery.hasPrincipalDiagnosisOf ( "Acute Respiratory Failure" )

define "Encounter With Diagnosis Of Acute Respiratory Failure Present On Admission":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery
    where EncounterWithSurgery.isDiagnosisPresentOnAdmission ( "Acute Respiratory Failure", "Present On Admission Or Clinically Undetermined" )

define "Encounter With Tracheostomy Present On Admission":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery
    where EncounterWithSurgery.isDiagnosisPresentOnAdmission ( "Tracheostomy Diagnoses", "Present On Admission Or Clinically Undetermined" )

define "Encounter With Tracheostomy Before Day Of First OR Procedure":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery
    let FirstProcedure: EncounterWithSurgery.firstAnesthesiaDuringHospitalization ( )
    with ["Procedure": "Tracheostomy Procedures"] TracheostomySurgery
      such that TracheostomySurgery.status = 'completed'
        and TracheostomySurgery.startsDuringHospitalization ( EncounterWithSurgery )
        and TracheostomySurgery.performed.toInterval ( ) starts before day of FirstProcedure.performed.toInterval ( )

define "Encounter With Tracheostomy Same Day Of First OR Procedure":
  "Elective Inpatient Encounter With OR Procedure Within 3 Days" EncounterWithSurgery
    let FirstProcedure: EncounterWithSurgery.firstAnesthesiaDuringHospitalization ( )
    with ["Procedure": "Tracheostomy Procedures"] TracheostomySurgery
      such that TracheostomySurgery.status = 'completed'
        and TracheostomySurgery.startsDuringHospitalization ( EncounterWithSurgery )
        and TracheostomySurgery.performed.toInterval ( ) starts during day of FirstProcedure.performed.toInterval ( )

define "Encounter With Tracheostomy Prior To Or On The Same Day Of First OR Procedure":
  "Encounter With Tracheostomy Before Day Of First OR Procedure"
    union "Encounter With Tracheostomy Same Day Of First OR Procedure"

define "Denominator Exclusions":
  "Encounter With Degenerative Neurological Disorder"
    union "Encounter With High Risk To Airway Head Neck And Thoracic Surgery"
    union "Encounter With Mechanical Ventilation That Starts More Than One Hour Prior To Start Of First OR Procedure"
    union "Encounter With Neuromuscular Disorder"
    union "Encounter With PaCO2 Greater Than 50 And Arterial pH Less Than 7.30 Within 48 Hours Prior To Start Of First OR Procedure"
    union "Encounter With PaO2 Less Than 50 Within 48 Hours Prior To Start Of First OR Procedure"
    union "Encounter With Principal Diagnosis Of Acute Respiratory Failure"
    union "Encounter With Diagnosis Of Acute Respiratory Failure Present On Admission"
    union "Encounter With Tracheostomy Present On Admission"
    union "Encounter With Tracheostomy Prior To Or On The Same Day Of First OR Procedure"

define "Risk Variable First AST In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstAST: QualifyingEncounter.firstAST ( )
    }

define "Risk Variable First Platelet Count In Encounter":
  "Initial Population" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstPlatelet: QualifyingEncounter.firstPlatelet ( )
    }

define fluent function encounterReason(Encounter Encounter):
  Encounter.reasonReference D
    return singleton from ( ( [ConditionEncounterDiagnosis] cA
        union [ConditionProblemsHealthConcerns] cB ) C
        where D.references ( C.id )
    )

define fluent function firstRespiratoryRate(QualifyingEncounter Encounter):
  First([USCoreRespiratoryRateProfile: "Respiratory rate"] FirstRespiration
      where FirstRespiration.status in { 'final', 'amended', 'corrected' }
        and FirstRespiration.effective.earliest() during QualifyingEncounter.hospitalizationWithObservation()
        and FirstRespiration.value is not null
      sort by effective.earliest()
  ).value as Quantity

define fluent function firstAlbumin(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "Albumin Lab Test"] FirstAlbuminTest
      where FirstAlbuminTest.status in { 'final', 'amended', 'corrected' }
        and FirstAlbuminTest.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity

define fluent function isEarliestDuringHospitalization(choice Choice<Procedure, LaboratoryResultObservation>, encounter Encounter):
  case
    when choice is Procedure then ( choice as Procedure ).earliestIsDuringHospitalization ( encounter )
    when choice is LaboratoryResultObservation then ( choice as LaboratoryResultObservation ).earliestOccursDuringHospitalization ( encounter ) 
    else false end

define fluent function earliestIsDuringHospitalization(procedure Procedure, encounter Encounter):
  procedure.performed.earliest ( ) during encounter.hospitalizationWithObservationAndOutpatientSurgeryService ( )
    and procedure.partOf is not null

define fluent function earliestOccursDuringHospitalization(observation LaboratoryResultObservation, encounter Encounter):
  observation.effective.earliest ( ) during encounter.hospitalizationWithObservationAndOutpatientSurgeryService ( )
    and observation.value is not null

define fluent function firstArterialpH(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "Arterial Blood pH"] FirstArterialpHTest
      where FirstArterialpHTest.status in { 'final', 'amended', 'corrected' }
        and FirstArterialpHTest.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity

define fluent function firstBodyTemperature(QualifyingEncounter Encounter):
  First(["USCoreBodyTemperatureProfile": "Body temperature"] FirstTemperature
      where FirstTemperature.status in { 'final', 'amended', 'corrected' }
        and FirstTemperature.effective.earliest() during QualifyingEncounter.hospitalizationWithObservation()
        and FirstTemperature.value is not null
      sort by effective.earliest()
  ).value as Quantity

define fluent function firstCarbonDioxide(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "Carbon Dioxide Partial Pressure In Arterial Blood"] FirstCarbonDioxideTest
      where FirstCarbonDioxideTest.status in { 'final', 'amended', 'corrected' }
        and FirstCarbonDioxideTest.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity

define fluent function firstHematocrit(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "Hematocrit Lab Test"] FirstHematocritTest
      where FirstHematocritTest.status in { 'final', 'amended', 'corrected' }
        and FirstHematocritTest.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity

define fluent function firstHeartRate(QualifyingEncounter Encounter):
  First(["USCoreHeartRateProfile": "Heart rate"] FirstHeartBeats
      where FirstHeartBeats.status in { 'final', 'amended', 'corrected' }
        and FirstHeartBeats.effective.earliest() during QualifyingEncounter.hospitalizationWithObservation()
        and FirstHeartBeats.value is not null
      sort by effective.earliest()
  ).value as Quantity

define fluent function firstBMI(QualifyingEncounter Encounter):
  First([USCoreBMIProfile] FirstBodyMass
      where FirstBodyMass.status in { 'final', 'amended', 'corrected' }
        and FirstBodyMass.effective.toInterval() starts during QualifyingEncounter.hospitalizationWithObservation()
        and FirstBodyMass.value is not null
      sort by effective.earliest()
  ).value as Quantity

define fluent function firstHemoglobin(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "Hemoglobin Lab Test"] FirstHemoglobinTest
      where FirstHemoglobinTest.status in { 'final', 'amended', 'corrected' }
        and FirstHemoglobinTest.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity

define fluent function claimDiagnosesWithPOA(encounter Encounter):
  encounter E
    let claim: ( [Claim] C
        where C.status = 'active'
          and C.use = 'claim'
          and exists ( C.item I
              where I.encounter.references ( E )
          )
    ),
    claimItem: ( claim.item I
        where I.encounter.references ( E )
    )
    return claim.diagnosis D
      where D.sequence in claimItem.diagnosisSequence
        and D.onAdmission is not null

define fluent function firstSodium(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "Sodium Lab Test"] FirstSodiumTest
      where FirstSodiumTest.status in { 'final', 'amended', 'corrected' }
        and FirstSodiumTest.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity

define fluent function firstCreatinine(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "Creatinine Lab Test"] FirstCreatinineTest
      where FirstCreatinineTest.status in { 'final', 'amended', 'corrected' }
        and FirstCreatinineTest.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity

define fluent function firstWhiteBloodCellCount(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "White Blood Cells Count Lab Test"] FirstWBCCount
      where FirstWBCCount.status in { 'final', 'amended', 'corrected' }
        and FirstWBCCount.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity

define fluent function startsDuringHospitalization(choice Choice<Procedure, LaboratoryResultObservation, ObservationScreeningAssessment>, enc Encounter):
  case
    when choice is Procedure then ( choice as Procedure ).performed.toInterval ( ) starts during enc.hospitalizationWithObservationAndOutpatientSurgeryService ( )
    when choice is LaboratoryResultObservation then ( choice as LaboratoryResultObservation ).effective.toInterval ( ) starts during enc.hospitalizationWithObservationAndOutpatientSurgeryService ( )
    when choice is ObservationScreeningAssessment then ( choice as ObservationScreeningAssessment ).effective.toInterval ( ) starts during enc.hospitalizationWithObservationAndOutpatientSurgeryService ( ) 
    else false end

define fluent function rank(targetProcedure Procedure, parentEncounter Encounter):
  singleton from ( targetProcedure P
      let claim: ( [Claim] C
          where C.status = 'active'
            and C.use = 'claim'
            and exists ( C.item I
                where I.encounter.references ( parentEncounter )
            )
      ),
      claimProc: ( claim.procedure proc
          where proc.procedure.references ( P )
      )
      return claimProc.sequence R
  )

define fluent function firstBicarbonate(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "Bicarbonate Lab Test"] FirstBicarbonateTest
      where FirstBicarbonateTest.status in { 'final', 'amended', 'corrected' }
        and FirstBicarbonateTest.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity

define fluent function firstBilirubin(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "Bilirubin Lab Test"] FirstBilirubinTest
      where FirstBilirubinTest.status in { 'final', 'amended', 'corrected' }
        and FirstBilirubinTest.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity

define fluent function "firstSystolicBloodPressure"(QualifyingEncounter Encounter):
  First("Qualifying Systolic Blood Pressure Reading" SBPReading
      where SBPReading.status in { 'final', 'amended', 'corrected' }
        and SBPReading.effective.earliest() during QualifyingEncounter.hospitalizationWithObservation()
      return singleton from(SBPReading.component SBPComponent
          where SBPComponent.code ~ "Systolic blood pressure"
          return SBPComponent.value as Quantity
      )
  )

define fluent function firstOxygen(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "Oxygen Partial Pressure In Arterial Blood"] FirstOxygenTest
      where FirstOxygenTest.status in { 'final', 'amended', 'corrected' }
        and FirstOxygenTest.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity

define fluent function firstLeukocyte(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "Leukocyte Count Lab Test"] FirstLeukocyteCount
      where FirstLeukocyteCount.status in { 'final', 'amended', 'corrected' }
        and FirstLeukocyteCount.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity

define fluent function starts30DaysOrLessAfterFirstAnesthesia(procedure Procedure, encounter Encounter):
  procedure.performed.toInterval ( ) starts 30 days or less after end of encounter.firstAnesthesiaDuringHospitalization ( ).performed.toInterval ( )

define fluent function "firstAnesthesiaDuringHospitalization"(QualifyingEncounter Encounter):
  First("Anesthesia Procedure List" anesthesia
      where anesthesia.status = 'completed'
        and anesthesia.startsDuringHospitalization(QualifyingEncounter)
      sort by start of performed.toInterval()
  )

define fluent function latestGeneralAnesthesiaOrMAC(event Procedure):
  Last("General Anesthesia And MAC" ProcedureList
      where ProcedureList.status = 'completed'
        and ProcedureList.performed.toInterval() ends before start of event.performed.toInterval()
      sort by start of performed.toInterval()
  )

define fluent function isNotAtProceduralHospitalLocationDuring(encounter Encounter, intrvl Interval<DateTime>):
  not exists ( encounter.location EncounterLocation
      with [Location] Location
        such that EncounterLocation.location.references ( Location )
          and Location.type.includesCode ( "ER" )
          and EncounterLocation.period starts during intrvl
  )

define fluent function isDuringHospitalization(choice Choice<Procedure, LaboratoryResultObservation>, enc Encounter):
  case
    when choice is Procedure then ( choice as Procedure ).performed.toInterval ( ) during enc.hospitalizationWithObservationAndOutpatientSurgeryService ( )
    when choice is LaboratoryResultObservation then ( choice as LaboratoryResultObservation ).effective.toInterval ( ) during enc.hospitalizationWithObservationAndOutpatientSurgeryService ( ) 
    else false end

define fluent function isNotAtProceduralHospitalLocation(encounter Encounter):
  not exists ( encounter.location EncounterLocation
      with [Location] Location
        such that EncounterLocation.location.references ( Location )
          and Location.type.includesCode ( "ER" )
  )

define fluent function firstBloodUreaNitrogen(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "Blood Urea Nitrogen Lab Test"] FirstBUN
      where FirstBUN.status in { 'final', 'amended', 'corrected' }
        and FirstBUN.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity

define fluent function firstAST(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "Aspartate transaminase Lab Test"] FirstASTTest
      where FirstASTTest.status in { 'final', 'amended', 'corrected' }
        and FirstASTTest.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity

define fluent function firstPlatelet(QualifyingEncounter Encounter):
  First([LaboratoryResultObservation: "Platelet Count Lab Test"] FirstPlateletCount
      where FirstPlateletCount.status in { 'final', 'amended', 'corrected' }
        and FirstPlateletCount.isEarliestDuringHospitalization(QualifyingEncounter)
      sort by effective.earliest()
  ).value as Quantity