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

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]

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

/*
@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))

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

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

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

/*
@description: Returns true if the given observation is a laboratory observation
*/
define fluent function isLaboratory(observation Choice<"SimpleObservation", 
"ObservationCancelled",
"NonPatientObservation",
"LaboratoryResultObservation",
"ObservationClinicalResult",
"ObservationScreeningAssessment">):
  exists (observation.category C
    where C ~ "laboratory"
  )

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

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

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

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":
  ["USCoreBloodPressureProfile"] 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(["USCoreRespiratoryRateProfile"] 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(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(start of QualifyingEncounter.hospitalizationWithObservation()) ) * 1.012 ) 
    else null

define fluent function "firstHeartRate"(QualifyingEncounter Encounter):
  First(["USCoreHeartRateProfile"] 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(["USCoreBodyTemperatureProfile"] 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
    )
  )