define "Initial Population":
  "Encounter With Creatinine And Without Obstetrical Conditions"

define "Denominator":
  "Initial Population"

define "Denominator Exclusion":
  "Encounter With Less Than 2 Creatinine Results Within 48 Hours Of Arrival"
    union "Encounter With Index eGFR Less Than 60 Within First 48 Hours"
    union "Encounter With 0.3 mg dL Or More Increase In Creatinine"
    union "Encounter With Kidney Dialysis Started 48 Hours Or Less After Arrival Without High Creatinine"
    union "Encounter With High Risk Diagnosis For AKI"
    union "Encounter With High Risk Procedures For AKI"

define "Numerator":
  "Encounter With 2 Times Serum Creatinine Increase"
    union "Encounter With Kidney Dialysis Started More Than 48 Hours After Arrival Without High Creatinine"

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 Payer":
  [USQualityCore.Coverage: type in "Payer Type"] Payer
    return {
      code: Payer.type,
      period: Payer.period
    }

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

/*
@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 resources referenced by the diagnosis element of the Encounter  
*/
define fluent function encounterDiagnosis(Encounter Encounter ):
  Encounter.reasonReference D
    return singleton from (([ConditionEncounterDiagnosis] union [ConditionProblemsHealthConcerns]) C where D.references(C.id))

define function ToString(value string): value.value

define function ToString(value uri): 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]

define function ToString(value EncounterStatus): value.value

define function ToDate(value date): 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

/*
@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 ProcedureStatus): value.value

define function ToString(value ClaimStatus): value.value

define function ToString(value Use): value.value

/*
@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: 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 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: Returns true if the given observation is a laboratory observation
*/
define fluent function isLaboratory(observation FHIR.Observation):
  exists (observation.category C
    where C ~ "laboratory"
  )

/*
@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: 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 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 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
    }

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
    }

define "Encounter With Age 18 And Length Of Stay 48 Hours Or More":
  ["Encounter": "Encounter Inpatient"] InpatientEncounter
    where Patient.sex ( ) in { "Male (finding)".code, "Female (finding)".code }
      and InpatientEncounter.period ends during day of "Measurement Period"
      and InpatientEncounter.status = 'finished'
      and AgeInYearsAt(date from start of InpatientEncounter.period) >= 18
      and ( duration in hours of InpatientEncounter.hospitalizationWithObservation ( ) >= 48 )

define "Inpatient Encounter With Creatinine":
  from
    "Encounter With Age 18 And Length Of Stay 48 Hours Or More" Encounter48Hours,
    ["LaboratoryResultObservation": "Creatinine Mass Per Volume"] CreatinineTest
    let HospitalizationPeriod: Encounter48Hours.hospitalizationWithObservation ( ),
    CreatinineTestStart: CreatinineTest.effective.earliest ( )
    where CreatinineTest.value as Quantity is not null
      and CreatinineTestStart during Interval[start of HospitalizationPeriod + 48 hours, end of HospitalizationPeriod]
      and CreatinineTest.status in { 'final', 'amended', 'corrected' }
    return Encounter48Hours

define "Encounter With Creatinine And Without Obstetrical Conditions":
  "Inpatient Encounter With Creatinine" EncounterWithCreatinine
    where not ( EncounterWithCreatinine.reasonCode in "Obstetrics and VTE Obstetrics"
        or EncounterWithCreatinine.encounterDiagnosis ( ).code in "Obstetrics and VTE Obstetrics"
    )

define "Risk Variable First Respiratory Rate In Encounter":
  "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstRespiratoryRate: "QualifyingEncounter".firstRespiratoryRate ( )
    }

define "Qualifying Creatinine Lab Result By Time":
  from
    "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter,
    ["LaboratoryResultObservation": "Creatinine Mass Per Volume"] CreatinineTestByTime
    let CrEncId: QualifyingEncounter.id,
    CrHospPeriod: QualifyingEncounter.hospitalizationWithObservation ( ),
    CrLabId: CreatinineTestByTime.id,
    CrTime: CreatinineTestByTime.effective.earliest ( ),
    CrTimeIssued: CreatinineTestByTime.issued,
    CrResult: CreatinineTestByTime.value as Quantity,
    CrResultValue: CrResult.value,
    CrResultUnit: CrResult.unit
    where CrTime during CrHospPeriod
      and CreatinineTestByTime.isLaboratory ( )
      and CreatinineTestByTime.status in { 'final', 'amended', 'corrected' }
      and CrResultUnit = 'mg/dL'
      and CreatinineTestByTime.value is not null
      and CreatinineTestByTime.value as Quantity > 0 'mg/dL'
    return Tuple {
      CrEncInPtId: CrEncId,
      CrHospitalization: CrHospPeriod,
      CrLabObsId: CrLabId,
      CrLabObsCategory: if CreatinineTestByTime.isLaboratory ( ) then 'laboratory' 
        else CreatinineTestByTime.isLaboratory ( ),
      CrLabObsCategory: CreatinineTestByTime.category,
      CrLabObsStatus: CreatinineTestByTime.status,
      CrLabResult: CrResult,
      CrLabResultUnit: CrResultUnit,
      CrLabResultValue: CrResultValue,
      CrLabTime: CrTime,
      CrLabTimeIssued: CrTimeIssued
    }
    sort by CrLabTime

define "Risk Variable Estimated Glomerular Filtration Rate For Males":
  "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      eGFR: "QualifyingEncounter".maleeGFR ( )
    }

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

define "Risk Variable First Systolic Blood Pressure In Encounter":
  "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstSystolicBP: "QualifyingEncounter".firstSystolicBloodPressure ( )
    }

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

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

define "Risk Variable Estimated Glomerular Filtration Rate For Females":
  "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      eGFR: "QualifyingEncounter".femaleeGFR ( )
    }

define "Risk Variable First Heart Rate In Encounter":
  "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstHeartRate: "QualifyingEncounter".firstHeartRate ( )
    }

define "Serum Creatinine Normal":
  if ( Patient.sex ( ) = "Female (finding)".code ) then 1.02 'mg/dL' 
    else 1.18 'mg/dL'

define "Encounter With 1.5 Times Serum Creatinine Increase":
  from
    "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter,
    ["LaboratoryResultObservation": "Creatinine Mass Per Volume"] HighCreatinineTest,
    ["LaboratoryResultObservation": "Creatinine Mass Per Volume"] LowCreatinineTest
    let LowCreatinineTestTime: LowCreatinineTest.effective.earliest ( ),
    HighCreatinineTestTime: HighCreatinineTest.effective.earliest ( ),
    HospitalWithObservationPeriod: QualifyingEncounter.hospitalizationWithObservation ( )
    where ( HighCreatinineTest.value > "Serum Creatinine Normal" )
      and LowCreatinineTest.status in { 'final', 'amended', 'corrected' }
      and HighCreatinineTest.status in { 'final', 'amended', 'corrected' }
      and HighCreatinineTest.value = "QualifyingEncounter".highestSerumCreatinineResult ( )
      and LowCreatinineTest.value = "QualifyingEncounter".lowestSerumCreatinineResult ( )
      and "QualifyingEncounter".oneAndAHalfIncreaseInCreatinine ( ) >= LowCreatinineTest.value
      and LowCreatinineTestTime 7 days or less before HighCreatinineTestTime
      and LowCreatinineTestTime during HospitalWithObservationPeriod
      and HighCreatinineTestTime during Interval[start of HospitalWithObservationPeriod + 48 hours, start of HospitalWithObservationPeriod + 30 days]
      and HighCreatinineTestTime during HospitalWithObservationPeriod
    return QualifyingEncounter

define "Encounter With 2 Times Serum Creatinine Increase":
  from
    "Encounter With 1.5 Times Serum Creatinine Increase" EncounterWithHighCreatinine,
    ["LaboratoryResultObservation": "Creatinine Mass Per Volume"] HighCreatinineTest,
    ["LaboratoryResultObservation": "Creatinine Mass Per Volume"] LowCreatinineTest
    let LowCreatinineTestTime: LowCreatinineTest.effective.earliest ( ),
    HighCreatinineTestTime: HighCreatinineTest.effective.earliest ( ),
    HospitalWithObservationPeriod: EncounterWithHighCreatinine.hospitalizationWithObservation ( )
    where ( HighCreatinineTest.value > "Serum Creatinine Normal" )
      and LowCreatinineTest.status in { 'final', 'amended', 'corrected' }
      and HighCreatinineTest.status in { 'final', 'amended', 'corrected' }
      and HighCreatinineTest.value = "EncounterWithHighCreatinine".highestSerumCreatinineResult ( )
      and LowCreatinineTest.value = "EncounterWithHighCreatinine".lowestSerumCreatinineResult ( )
      and ( HighCreatinineTest.value as Quantity ) >= ( LowCreatinineTest.value as Quantity )
      and LowCreatinineTestTime 7 days or less before HighCreatinineTestTime
      and LowCreatinineTestTime during HospitalWithObservationPeriod
      and HighCreatinineTestTime during Interval[start of HospitalWithObservationPeriod + 48 hours, start of HospitalWithObservationPeriod + 30 days]
      and HighCreatinineTestTime during HospitalWithObservationPeriod
    return EncounterWithHighCreatinine

define "Encounter With Kidney Dialysis Started More Than 48 Hours After Arrival":
  from
    ["Procedure": "Hospital Based Dialysis Services"] Dialysis,
    "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter
    let HospitalWithObservationPeriod: QualifyingEncounter.hospitalizationWithObservation ( )
    where Dialysis.performed.toInterval ( ) starts during Interval[start of HospitalWithObservationPeriod + 48 hours, end of HospitalWithObservationPeriod]
      and Dialysis.performed.toInterval ( ) starts during HospitalWithObservationPeriod
      and Dialysis.status = 'completed'
    return QualifyingEncounter

define "Encounter With Kidney Dialysis Started More Than 48 Hours After Arrival Without High Creatinine":
  "Encounter With Kidney Dialysis Started More Than 48 Hours After Arrival" EncounterWithDialysisAfter48Hours
    where not ( exists ( "Encounter With 2 Times Serum Creatinine Increase" EncounterWithHighCreatinine
          where ( EncounterWithHighCreatinine.period includes EncounterWithDialysisAfter48Hours.period )
      )
    )

define "Numerator":
  "Encounter With 2 Times Serum Creatinine Increase"
    union "Encounter With Kidney Dialysis Started More Than 48 Hours After Arrival Without High Creatinine"

define "Risk Variable All Encounter Diagnoses With POA Indication":
  from
    "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter,
    [Claim] clm
    where clm.status = 'active'
      and clm.use = 'claim'
      and exists ( clm.item ClaimItem
          where ClaimItem.encounter.references ( QualifyingEncounter )
            and exists ( clm.diagnosis Dx
                where Dx.sequence in clm.item.diagnosisSequence
                  and Dx.onAdmission in "Present on Admission or Clinically Undetermined"
            )
      )

define "Initial Population":
  "Encounter With Creatinine And Without Obstetrical Conditions"

define "Denominator":
  "Initial Population"

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

define "Risk Variable First Temperature In Encounter":
  "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter
    return Tuple {
      encounterId: QualifyingEncounter.id,
      firstTemperature: "QualifyingEncounter".firstBodyTemperature ( )
    }

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

define "Encounter With Less Than 2 Creatinine Results Within 48 Hours Of Arrival":
  "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter
    where ( Count("QualifyingEncounter".creatinineLabTestwithResultwithinFirst48Hours()) < 2 )

define "Male Encounter With eGFR Less Than 60":
  "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter
    where "QualifyingEncounter".maleeGFR ( ) is not null
      and "QualifyingEncounter".maleeGFR ( ) as Decimal < 60

define "Female Encounter With eGFR Less Than 60":
  "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter
    where "QualifyingEncounter".femaleeGFR ( ) is not null
      and "QualifyingEncounter".femaleeGFR ( ) as Decimal < 60

define "Encounter With Index eGFR Less Than 60 Within First 48 Hours":
  "Male Encounter With eGFR Less Than 60"
    union "Female Encounter With eGFR Less Than 60"

define "Increase Of 0.3 Or More Using Lowest Creatinine Within 24 Hours":
  from
    "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter,
    ["LaboratoryResultObservation": "Creatinine Mass Per Volume"] IndexCreatinineLabResult,
    ["LaboratoryResultObservation": "Creatinine Mass Per Volume"] SubsequentCreatinineLabResult
    let IndexCreatinineLabResultTime: IndexCreatinineLabResult.effective.earliest ( ),
    SubsequentCreatinineLabResultTime: SubsequentCreatinineLabResult.effective.earliest ( ),
    HospitalWithObservationPeriod: QualifyingEncounter.hospitalizationWithObservation ( )
    where IndexCreatinineLabResult.status in { 'final', 'amended', 'corrected' }
      and SubsequentCreatinineLabResult.status in { 'final', 'amended', 'corrected' }
      and ( ( SubsequentCreatinineLabResult.value as Quantity ) - ( IndexCreatinineLabResult.value as Quantity ) ) > 0.299 'mg/dL'
      and IndexCreatinineLabResult.value = "QualifyingEncounter".lowestSerumCreatinineResult ( )
      and IndexCreatinineLabResultTime during Interval[SubsequentCreatinineLabResultTime - 48 hours, SubsequentCreatinineLabResultTime]
      and IndexCreatinineLabResultTime during HospitalWithObservationPeriod
      and IndexCreatinineLabResultTime during Interval[start of HospitalWithObservationPeriod, start of HospitalWithObservationPeriod + 24 hours]
      and SubsequentCreatinineLabResultTime during HospitalWithObservationPeriod
      and SubsequentCreatinineLabResultTime during Interval[start of HospitalWithObservationPeriod, start of HospitalWithObservationPeriod + 48 hours]
      and IndexCreatinineLabResult.id != SubsequentCreatinineLabResult.id
    return QualifyingEncounter

define "Increase Of 0.3 Or More Using First Creatinine Within First 48 Hours":
  from
    "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter,
    ["LaboratoryResultObservation": "Creatinine Mass Per Volume"] IndexCreatinineLabResult,
    ["LaboratoryResultObservation": "Creatinine Mass Per Volume"] SubsequentCreatinineLabResult
    let IndexCreatinineLabResultTime: IndexCreatinineLabResult.effective.earliest ( ),
    SubsequentCreatinineLabResultTime: SubsequentCreatinineLabResult.effective.earliest ( ),
    HospitalWithObservationPeriod: QualifyingEncounter.hospitalizationWithObservation ( )
    where IndexCreatinineLabResult.status in { 'final', 'amended', 'corrected' }
      and SubsequentCreatinineLabResult.status in { 'final', 'amended', 'corrected' }
      and ( ( SubsequentCreatinineLabResult.value as Quantity ) - ( IndexCreatinineLabResult.value as Quantity ) ) > 0.299 'mg/dL'
      and IndexCreatinineLabResult.value as Quantity = singleton from "QualifyingEncounter".earliestSerumCreatinineResult ( )
      and IndexCreatinineLabResultTime during Interval[SubsequentCreatinineLabResultTime - 48 hours, SubsequentCreatinineLabResultTime]
      and IndexCreatinineLabResultTime during HospitalWithObservationPeriod
      and SubsequentCreatinineLabResultTime during Interval[start of HospitalWithObservationPeriod, start of HospitalWithObservationPeriod + 48 hours]
      and SubsequentCreatinineLabResultTime during HospitalWithObservationPeriod
      and IndexCreatinineLabResultTime during Interval[start of HospitalWithObservationPeriod, start of HospitalWithObservationPeriod + 48 hours]
      and IndexCreatinineLabResult.id != SubsequentCreatinineLabResult.id
    return QualifyingEncounter

define "Encounter With 0.3 mg dL Or More Increase In Creatinine":
  "Increase Of 0.3 Or More Using Lowest Creatinine Within 24 Hours"
    union "Increase Of 0.3 Or More Using First Creatinine Within First 48 Hours"

define "Encounter With Kidney Dialysis Started 48 Hours Or Less After Arrival":
  from
    ["Procedure": "Hospital Based Dialysis Services"] Dialysis,
    "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter
    let HospitalWithObservationPeriod: QualifyingEncounter.hospitalizationWithObservation ( )
    where Dialysis.status = 'completed'
      and Dialysis.performed.toInterval ( ) starts during Interval[start of HospitalWithObservationPeriod, start of HospitalWithObservationPeriod + 48 hours]
      and Dialysis.performed.toInterval ( ) starts during HospitalWithObservationPeriod
    return QualifyingEncounter

define "Encounter With Kidney Dialysis Started 48 Hours Or Less After Arrival Without High Creatinine":
  "Encounter With Kidney Dialysis Started 48 Hours Or Less After Arrival" EncounterWithKidneyDialysis48HoursOrAfter
    where not ( exists ( "Encounter With 2 Times Serum Creatinine Increase" EncounterWithHighCreatinine
          where ( EncounterWithHighCreatinine.period includes EncounterWithKidneyDialysis48HoursOrAfter.period )
      )
    )

define "Encounter With High Risk Diagnosis For AKI":
  "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter
    where ( QualifyingEncounter.reasonCode in "High Risk Diagnosis for AKI"
        or QualifyingEncounter.encounterDiagnosis ( ).code in "High Risk Diagnosis for AKI"
    )

define "Encounter With High Risk Procedures For AKI":
  "Encounter With Creatinine And Without Obstetrical Conditions" QualifyingEncounter
    with ["Procedure": "High Risk Procedures for AKI"] HighRiskProcedures
      such that HighRiskProcedures.status = 'completed'
        and HighRiskProcedures.performed.toInterval ( ) starts during QualifyingEncounter.hospitalizationWithObservation ( )

define "Denominator Exclusion":
  "Encounter With Less Than 2 Creatinine Results Within 48 Hours Of Arrival"
    union "Encounter With Index eGFR Less Than 60 Within First 48 Hours"
    union "Encounter With 0.3 mg dL Or More Increase In Creatinine"
    union "Encounter With Kidney Dialysis Started 48 Hours Or Less After Arrival Without High Creatinine"
    union "Encounter With High Risk Diagnosis For AKI"
    union "Encounter With High Risk Procedures For AKI"

define fluent function "firstRespiratoryRate"(QualifyingEncounter Encounter):
  First(["USCore.RespiratoryRateProfile"] FirstRespiration
      where FirstRespiration.effective.earliest() during QualifyingEncounter.hospitalizationWithObservation()
        and FirstRespiration.value is not null
      sort by effective.earliest()
  ).value as Quantity

define fluent function "maleeGFR"(QualifyingEncounter Encounter):
  if Patient.sex () = "Male (finding)".code then ( 142 * Min({("QualifyingEncounter".indexCreatinine().value / 0.9), 1 }) ^ ( - 0.302 ) * Max({("QualifyingEncounter".indexCreatinine().value / 0.9), 1 }) ^ ( - 1.200 ) * 0.9938 ^ ( AgeInYearsAt(date from start of QualifyingEncounter.hospitalizationWithObservation()) ) ) 
    else null

define fluent function "indexCreatinine"(QualifyingEncounter Encounter):
  Coalesce("QualifyingEncounter".lowestSerumCreatinineIn24Hours(), singleton from "QualifyingEncounter".firstSerumCreatinineIn48Hours())

define fluent function "lowestSerumCreatinineIn24Hours"(QualifyingEncounter Encounter):
  Min((from
        "Qualifying Creatinine Lab Result By Time" LabTestsLow
        let LabResult: LabTestsLow.CrLabResult
        where LabTestsLow.CrEncInPtId = QualifyingEncounter.id
          and LabTestsLow.CrLabTime during Interval[start of QualifyingEncounter.hospitalizationWithObservation(), start of QualifyingEncounter.hospitalizationWithObservation() + 24 hours]
    ).CrLabResult
  )

define fluent function "firstSerumCreatinineIn48Hours"(QualifyingEncounter Encounter):
  from
    "Qualifying Creatinine Lab Result By Time" LabTests
    let LabResult: LabTests.CrLabResult
    where ( "QualifyingEncounter".earliestSerumCreatinineTimeIn48Hours ( ) = LabTests.CrLabTime )
    return LabResult as Quantity

define fluent function "earliestSerumCreatinineTimeIn48Hours"(QualifyingEncounter Encounter):
  ( Min((from
          "Qualifying Creatinine Lab Result By Time" LabTests48
          let LabResult48: LabTests48.CrLabResult
          where LabTests48.CrEncInPtId = QualifyingEncounter.id
            and LabTests48.CrLabTime during Interval[start of QualifyingEncounter.hospitalizationWithObservation(), start of QualifyingEncounter.hospitalizationWithObservation() + 48 hours]
      ).CrLabTime
    )
  )

define fluent function "firstSystolicBloodPressure"(QualifyingEncounter Encounter):
  First("Qualifying Blood Pressure Reading" SBPReading
      where 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 "femaleeGFR"(QualifyingEncounter Encounter):
  if Patient.sex () = "Female (finding)".code then ( 142 * Min({("QualifyingEncounter".indexCreatinine().value / 0.7), 1 }) ^ ( - 0.241 ) * Max({("QualifyingEncounter".indexCreatinine().value / 0.7), 1 }) ^ ( - 1.200 ) * 0.9938 ^ ( AgeInYearsAt(date from start of QualifyingEncounter.hospitalizationWithObservation()) ) * 1.012 ) 
    else null

define fluent function "firstHeartRate"(QualifyingEncounter Encounter):
  First(["USCore.HeartRateProfile"] FirstHeartBeats
      where FirstHeartBeats.effective.earliest() during QualifyingEncounter.hospitalizationWithObservation()
        and FirstHeartBeats.value is not null
      sort by effective.earliest()
  ).value as Quantity

define fluent function "highestSerumCreatinineResult"(QualifyingEncounter Encounter):
  ( Max((from
          "Qualifying Creatinine Lab Result By Time" LabTests
          let LabResult: LabTests.CrLabResult
          where LabTests.CrEncInPtId = QualifyingEncounter.id
      ).CrLabResult
    )
  )

define fluent function "lowestSerumCreatinineResult"(QualifyingEncounter Encounter):
  ( Min((from
          "Qualifying Creatinine Lab Result By Time" LabTests
          let LabResult: LabTests.CrLabResult
          where LabTests.CrEncInPtId = QualifyingEncounter.id
      ).CrLabResult
    )
  )

define fluent function "oneAndAHalfIncreaseInCreatinine"(QualifyingEncounter Encounter):
  "QualifyingEncounter".highestSerumCreatinineResult ( ) / 1.5

define fluent function "firstBodyTemperature"(QualifyingEncounter Encounter):
  First(["USCore.BodyTemperatureProfile"] FirstTemperature
      where FirstTemperature.effective.earliest() during QualifyingEncounter.hospitalizationWithObservation()
        and FirstTemperature.value is not null
      sort by effective.earliest()
  ).value as Quantity

define fluent function "creatinineLabTestwithResultwithinFirst48Hours"(QualifyingEncounter Encounter):
  from
    ["LaboratoryResultObservation": "Creatinine Mass Per Volume"] CreatinineTest
    where CreatinineTest.value as Quantity is not null
      and CreatinineTest.effective.earliest ( ) during Interval[start of QualifyingEncounter.hospitalizationWithObservation ( ), start of QualifyingEncounter.hospitalizationWithObservation ( ) + 48 hours]
      and CreatinineTest.effective.earliest ( ) during QualifyingEncounter.hospitalizationWithObservation ( )
      and CreatinineTest.status in { 'final', 'amended', 'corrected' }
    return CreatinineTest

define fluent function "earliestSerumCreatinineResult"(QualifyingEncounter Encounter):
  from
    "Qualifying Creatinine Lab Result By Time" LabTests
    let LabResult: LabTests.CrLabResult
    where ( "QualifyingEncounter".earliestSerumCreatinineTime ( ) = LabTests.CrLabTime )
    return LabResult as Quantity

define fluent function "earliestSerumCreatinineTime"(QualifyingEncounter Encounter):
  ( Min((from
          "Qualifying Creatinine Lab Result By Time" LabTestsEarly
          let LabResultEarly: LabTestsEarly.CrLabResult
          where LabTestsEarly.CrEncInPtId = QualifyingEncounter.id
      ).CrLabTime
    )
  )