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":
  [USQualityCore.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
    }

define function ToString(value EncounterStatus): value.value

/*
@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 ToDate(value date): value.value

define function ToString(value string): value.value

define function ToString(value ProcedureStatus): value.value

define function ToDateTime(value dateTime): value.value

define function ToDateTime(value instant): value.value

/*
@description: Converts the given FHIR [Quantity](https://hl7.org/fhir/datatypes.html#Quantity) 
value to a CQL Quantity
@comment: If the given quantity has a comparator specified, a runtime error is raised. If the given quantity
has a system other than UCUM (i.e. `http://unitsofmeasure.org`) or CQL calendar units (i.e. `http://hl7.org/fhirpath/CodeSystem/calendar-units`)
an error is raised. For UCUM to calendar units, the `ToCalendarUnit` function is used.
@seealso: ToCalendarUnit
*/
define function ToQuantity(quantity FHIR.Quantity):
    case
        when quantity is null then null
        when quantity.value is null then null
        when quantity.comparator is not null then
            Message(null, true, 'FHIRHelpers.ToQuantity.ComparatorQuantityNotSupported', 'Error', 'FHIR Quantity value has a comparator and cannot be converted to a System.Quantity value.')
        when quantity.system is null or quantity.system.value = 'http://unitsofmeasure.org'
              or quantity.system.value = 'http://hl7.org/fhirpath/CodeSystem/calendar-units' then
            System.Quantity { value: quantity.value.value, unit: ToCalendarUnit(Coalesce(quantity.code.value, quantity.unit.value, '1')) }
        else
            Message(null, true, 'FHIRHelpers.ToQuantity.InvalidFHIRQuantity', 'Error', 'Invalid FHIR Quantity code: ' & quantity.unit.value & ' (' & quantity.system.value & '|' & quantity.code.value & ')')
    end

/*
@description: Converts a UCUM definite duration unit to a CQL calendar duration
unit using conversions specified in the [quantities](https://cql.hl7.org/02-authorsguide.html#quantities) 
topic of the CQL specification.
@comment: Note that for durations above days (or weeks), the conversion is understood to be approximate
*/
define function ToCalendarUnit(unit System.String):
    case unit
        when 'ms' then 'millisecond'
        when 's' then 'second'
        when 'min' then 'minute'
        when 'h' then 'hour'
        when 'd' then 'day'
        when 'wk' then 'week'
        when 'mo' then 'month'
        when 'a' then 'year'
        else unit
    end

define function ToString(value ObservationStatus): value.value

define function ToString(value ClaimStatus): value.value

define function ToString(value Use): value.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 FHIR.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<FHIR.dateTime, FHIR.Period, FHIR.Age, FHIR.Range>):
  (choice.toInterval()) period
    return
      if (period.hasStart()) then start of period
      else end of period

/*
@description: Normalizes a value that is a choice of timing-valued types to an equivalent interval
@comment: Normalizes a choice type of FHIR.dateTime, FHIR.Period, FHIR.Timing, FHIR.instance, FHIR.string, FHIR.Age, or FHIR.Range 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 FHIR, allowing this function to be used across any resource.

The input can be provided as a dateTime, Period, Timing, instant, string, Age, or Range.
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 Period, the result is a DateTime Interval.
If the input is a Timing, an error is raised indicating a single interval cannot be computed from a Timing.
If the input is an instant, the result is a DateTime Interval beginning and ending on that instant.
If the input is a string, an error is raised indicating a single interval cannot be computed from a string.
If the input is an Age, the result is a DateTime Interval beginning when the patient was the given Age,
and ending immediately prior to when the patient was the given Age plus one year.
If the input is a Range, the result is a DateTime Interval beginning when the patient was the Age given
by the low end of the Range, and ending immediately prior to when the patient was the Age given by the
high end of the Range plus one year.

NOTE: Due to the
complexity of determining a single interval from a Timing or String type, this function will throw a run-time exception if it is used
with a Timing or String.
*/
define fluent function toInterval(choice Choice<FHIR.dateTime, FHIR.Period, FHIR.Timing, FHIR.instant, FHIR.string, FHIR.Age, FHIR.Range>):
  case
    when choice is FHIR.dateTime then
      Interval[FHIRHelpers.ToDateTime(choice as FHIR.dateTime), FHIRHelpers.ToDateTime(choice as FHIR.dateTime)]
    when choice is FHIR.Period then
      FHIRHelpers.ToInterval(choice as FHIR.Period)
    when choice is FHIR.instant then
      Interval[FHIRHelpers.ToDateTime(choice as FHIR.instant), FHIRHelpers.ToDateTime(choice as FHIR.instant)]
    when choice is FHIR.Age then
      Interval[FHIRHelpers.ToDate(Patient.birthDate) + FHIRHelpers.ToQuantity(choice as FHIR.Age),
        FHIRHelpers.ToDate(Patient.birthDate) + FHIRHelpers.ToQuantity(choice as FHIR.Age) + 1 year)
    when choice is FHIR.Range then
      Interval[FHIRHelpers.ToDate(Patient.birthDate) + FHIRHelpers.ToQuantity((choice as FHIR.Range).low),
        FHIRHelpers.ToDate(Patient.birthDate) + FHIRHelpers.ToQuantity((choice as FHIR.Range).high) + 1 year)
    when choice is FHIR.Timing then
      Message(null as Interval<DateTime>, true, 'NOT_IMPLEMENTED', 'Error', 'Calculation of an interval from a Timing value is not supported')
    when choice is FHIR.string then
      Message(null as Interval<DateTime>, true, 'NOT_IMPLEMENTED', 'Error', 'Calculation of an interval from a String value is not supported')
    else
      null as Interval<DateTime>
  end

/*
@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<FHIR.Reference>, resource FHIR.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 FHIR.Reference, resource FHIR.Resource):
  resource.id = Last(Split(reference.reference, '/'))

/*
@description: Returns the single extension (if present) on the given resource with the specified url.
@comment: This function uses singleton from to ensure that a run-time exception is thrown if there
is more than one extension on the given resource with the specified url.
*/
define fluent function ext(domainResource DomainResource, url String):
  singleton from domainResource.exts(url)

/*
@description: Returns any extensions defined on the given resource with the specified url
*/
define fluent function exts(domainResource DomainResource, url String):
  domainResource.extension E
    where E.url = url
    return E

/*
@description: Returns any extensions defined on the given element with the specified url.
*/
define fluent function exts(element Element, url String):
  element.extension E
    where E.url = url
    return E

/*
@description: Returns the single extension (if present) on the given element with the specified url.
@comment: This function uses singleton from to ensure that a run-time exception is thrown if there
is more than one extension on the given element with the specified url.
*/
define fluent function ext(element Element, url String):
  singleton from element.exts(url)

/*
@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<FHIR.dateTime, FHIR.Period, FHIR.Age, FHIR.Range>):
  (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<CodeableConcept>, code Concept):
  exists (codeList C where C ~ code)

define fluent function race(patient Patient):
  (patient.ext('http://hl7.org/fhir/us/core/StructureDefinition/us-core-race')) E
    return {
      ombCategory: (E.exts('ombCategory')) o return o.value as FHIR.Coding,
      detailed: (E.exts('detailed')) d return d.value as FHIR.Coding,
      text: E.ext('text').value as FHIR.string
    }

/*
@description: Returns the sex element as defined for the USCore patient profile
*/
define fluent function sex(patient Patient):
  patient.ext('http://hl7.org/fhir/us/core/StructureDefinition/us-core-sex').value as FHIR.code

define fluent function ethnicity(patient Patient):
  (patient.ext('http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity')) E
    return {
      ombCategory: E.ext('ombCategory').value as FHIR.Coding,
      detailed: (E.exts('detailed')) d return d.value as FHIR.Coding,
      text: E.ext('text').value as FHIR.string
    }

/*
@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 System.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 System.ValueSet, poaValueSet System.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 CodeableConcept in "ASA Physical Status Class"
    return ASAclass.value as CodeableConcept

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)":
  ["USCore.BMIProfile"] 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":
  ["USCore.BloodPressureProfile"] 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([USCore.RespiratoryRateProfile: "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(["USCore.BodyTemperatureProfile": "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(["USCore.HeartRateProfile": "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([USCore.BMIProfile] 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 interval(choice Choice<Procedure, LaboratoryResultObservation, Encounter>):
  case
    when choice is Procedure then ( choice as Procedure ).performed.toInterval ( )
    when choice is LaboratoryResultObservation then ( choice as LaboratoryResultObservation ).effective.toInterval ( )
    when choice is Encounter then ( choice as Encounter ).period.toInterval ( ) 
    else null as Interval<DateTime>end

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