//Common Retrievals define "Encounters":   [Encounter]

define "EncounterInpatient":   ([Encounter: "Encounter Inpatient"]     union [Encounter: class in "NHSN Inpatient Encounter Class Codes"]) Encounters   where Encounters.status in {'in-progress', 'finished', 'triaged', 'onleave', 'entered-in-error'}     and Encounters.period overlaps "Measurement Period"

define "EncounterObservation":   ([Encounter: "Observation Services"]     union [Encounter: class in {"observation encounter"}]) Encounters   where Encounters.status in {'in-progress', 'finished', 'triaged', 'onleave', 'entered-in-error'}     and Encounters.period overlaps "Measurement Period"

define "Encounters with Patient Hospital Locations":   [Encounter] Encounters   where exists(     Encounters.location EncounterLocation     let types: NHSNHelpers.GetLocation(EncounterLocation.location).type     where exists(       types type       where type in "Inpatient, Emergency, and Observation Locations"     )     and EncounterLocation.period overlaps Encounters.period     and Encounters.status in {'in-progress', 'finished', 'triaged', 'onleave', 'entered-in-error' }     and Encounters.period overlaps "Measurement Period"   )

//---------------------------------- // Initial Population //---------------------------------- define "Initial Population":   EncounterInpatient   union EncounterObservation   union "Encounters with Patient Hospital Locations"

define "SDE Encounter":    "Encounters" Encounters   where not CheckIP(Encounters)   and exists(     "Initial Population" IP     where Encounters.period overlaps IP.period)   return SharedResource.EncounterResource(Encounters,   {FHIR.canonical{value: 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter'}})

define "SDE ACH Daily ServiceRequest":   ([ServiceRequest: "COVID_19 (Tests for SARS_CoV_2 Nucleic Acid)"]    union  [ServiceRequest: "COVID_19 (Tests for SARS_CoV_2 Antigen)"]    union  [ServiceRequest: "Influenza (Tests for influenza A or B virus Nucleic Acid)"]   union  [ServiceRequest: "Influenza (Tests for influenza A or B virus Antigen)"]   union  [ServiceRequest: "RSV (Tests for RSV Nucleic Acid)"]   union  [ServiceRequest: "RSV (Tests for RSV Antigen)"]   ) ServiceRequests     where ServiceRequests.intent ~ 'order'       and ServiceRequests.status ~ 'completed'       and exists("Initial Population")   return SharedResource.ServiceRequestResource(ServiceRequests,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-servicerequest'}})

define "RSV Observation":   ([Observation: "RSV (Tests for RSV Nucleic Acid)"]   union [Observation: "RSV (Tests for RSV Antigen)"]      ) Observations     where exists(Observations.category Category where Category ~ "laboratory")       and Observations.status in {'final','registered','preliminary','partial'}       and exists("Initial Population")

//further constrain RSV observation for 8 day lookback define "RSV PRE Admission Observation":   "RSV Observation" O    where exists(EncounterInpatient E      where (       NHSNHelpers."Normalize Interval"(O.effective) 8 days or less on or before start of E.period       or NHSNHelpers."Normalize Interval"(GetSpecimen(O.specimen).collection.collected) 8 days or less on or before start of E.period       )       and start of E.period during "Measurement Period"     )

//return the Specimen related to the RSV Observation Pre Admission define "SDE RSV Specimen":   "RSV PRE Admission Observation" ObservationWithSpecimen     let Specimen: GetSpecimen(ObservationWithSpecimen.specimen)     return SharedResource.SpecimenResource(Specimen,     {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-specimen'}})

//----------------------------------------------- // Logic related to Laboratory //----------------------------------------------- //Lab Observations define "COVID And Influenza Observation":   ([Observation: "Influenza (Tests for influenza A or B virus Nucleic Acid)"]    union [Observation: "Influenza (Tests for influenza A or B virus Antigen)"]   union [Observation: "COVID_19 (Tests for SARS_CoV_2 Nucleic Acid)"]   union [Observation: "COVID_19 (Tests for SARS_CoV_2 Antigen)"]   ) Observations     where exists(Observations.category Category where Category ~ "laboratory")       and Observations.status in {'final','registered','preliminary','partial'}       and exists("Initial Population")

define "ACH Daily Observation":   "RSV Observation"   union "COVID And Influenza Observation"

//return the Specimen related to the Observation during the Measurement Period define "SDE ACH Daily Specimen":   "ACH Daily Observation" ObservationWithSpecimen     let Specimen: GetSpecimen(ObservationWithSpecimen.specimen)     return SharedResource.SpecimenResource(Specimen,     {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-specimen'}})

//Lab DiagnosticReport define "COVID And Influenza DiagnosticReport":   ([DiagnosticReport: "COVID_19 (Tests for SARS_CoV_2 Nucleic Acid)"]     union [DiagnosticReport: "COVID_19 (Tests for SARS_CoV_2 Antigen)"]     union [DiagnosticReport: "Influenza (Tests for influenza A or B virus Nucleic Acid)"]     union [DiagnosticReport: "Influenza (Tests for influenza A or B virus Antigen)"]   ) Reports     where exists("Initial Population")       and Reports.status in {'final','registered','preliminary','partial'}

define "RSV DiagnosticReport":   ([DiagnosticReport: "RSV (Tests for RSV Nucleic Acid)"]     union [DiagnosticReport: "RSV (Tests for RSV Antigen)"]   ) Reports     where exists("Initial Population")       and Reports.status in {'final','registered','preliminary','partial'}

define "ACH Daily DiagnosticReport":   "COVID And Influenza DiagnosticReport"     union "RSV DiagnosticReport"

//return the DiagnosticReport during the Measurement Period define "SDE ACH Daily DiagnosticReport":   "ACH Daily DiagnosticReport" Reports     return SharedResource.DiagnosticReportLabResource(Reports,     {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-diagnosticreport-lab'}})

//return the RSV DiagnosticReport pre admission define "SDE RSV DiagnosticReport":   "RSV DiagnosticReport" Reports     return SharedResource.DiagnosticReportLabResource(Reports,     {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-diagnosticreport-lab'}})

//return the Observation during the Measurement Period define "SDE ACH Daily Observation":   "ACH Daily Observation" Observations     return SharedResource.ObservationLabResource(Observations,     {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-observation-lab'}})

//To catch all isolation precautions define "SDE All Procedures":   [Procedure] P   where exists("Initial Population")   return SharedResource.ProcedureResource(P,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-procedure'}})

define "SDE Encounter Discharge Dispositions":  "Initial Population" DischargeDispositions    where DischargeDispositions.hospitalization.dischargeDisposition in "Discharge Disposition"   return SharedResource.EncounterResource(DischargeDispositions,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-encounter'}})

define "SDE Covid or Influenza Medication Ordered":   [MedicationRequest] RPSMedRequest     let Meds: GetMedicationCode(RPSMedRequest.medication)     where (Meds in "Anakinra"             or Meds in "Baloxavir"             or Meds in "Bamlanivimab"             or Meds in "Baricitinib"             or Meds in "Bebtelovimab"             or Meds in "Casirivimab"             or Meds in "Casirivimab / Imdevimab"             or Meds in "COVID19 RxNorm Value Set for Tocilizumab"             or Meds in "Etesevimab"             or Meds in "Imdevimab"             or Meds in "Molnupiravir"             or Meds in "Nirmatrelvir / Ritonavir"             or Meds in "Oseltamivir"             or Meds in "Peramivir"             or Meds in "Remdesivir"             or Meds in "Sarilumab"             or Meds in "Sotrovimab"                 or Meds in "Tofacitinib"             or Meds in "Zanamivir")       and exists("Initial Population")       and NHSNHelpers."Normalize Interval"(RPSMedRequest.authoredOn) during "Measurement Period"     return MedicationRequestResource(RPSMedRequest,     {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-medicationrequest'}})

define "SDE Minimal Patient":   Patient p   where exists("Initial Population")   return SharedResource.PatientResource(p,    {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/cross-measure-patient'}})

define "Observations":   [Observation]

//To catch all isolation precautions define "SDE All Observations":   "Observations" O   where exists("Initial Population")   return SharedResource.ObservationLabResource(O,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-observation'}})

define "SDE Covid or Influenza Medication Administered":   [MedicationAdministration] RPSMedAdmin     let Meds: GetMedicationCode(RPSMedAdmin.medication)    where (Meds in "Anakinra"             or Meds in "Bamlanivimab"             or Meds in "Baloxavir"             or Meds in "Baricitinib"             or Meds in "Bebtelovimab"             or Meds in "Casirivimab"             or Meds in "Casirivimab / Imdevimab"             or Meds in "COVID19 RxNorm Value Set for Tocilizumab"             or Meds in "Etesevimab"             or Meds in "Imdevimab"             or Meds in "Molnupiravir"             or Meds in "Nirmatrelvir / Ritonavir"             or Meds in "Oseltamivir"             or Meds in "Peramivir"             or Meds in "Remdesivir"             or Meds in "Sarilumab"             or Meds in "Sotrovimab"                 or Meds in "Tofacitinib"             or Meds in "Zanamivir")       and RPSMedAdmin.status ~ 'completed'       and exists("Initial Population")       and NHSNHelpers."Normalize Interval"(RPSMedAdmin.effective) during "Measurement Period"     return SharedResource.MedicationAdministrationResource(RPSMedAdmin,     {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-medicationadministration'}})

define "SDE Medication":   ("SDE Covid or Influenza Medication Ordered"   union "SDE Covid or Influenza Medication Administered") MedReqOrAdmin   where MedReqOrAdmin.medication is FHIR.Reference   return SharedResource.MedicationResource(GetMedicationFrom(MedReqOrAdmin.medication),   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-medication'}})

define "DiagnosticReports":   [DiagnosticReport]

define "RSV Observations":   "Observations" Observations   where Observations.code in "RSV (Tests for RSV Nucleic Acid)"     or Observations.code in "RSV (Tests for RSV Antigen)"

define "RSV DiagnosticReport Observations":   "DiagnosticReports" Reports   where exists(     "RSV Observations" Observations     where Reports.result.references(Observations)   )

define "RSV DiagnosticReport Result from Lab":   [DiagnosticReport] Reports     where exists("RSV DiagnosticReport Observations")       and Reports.status in {'final','registered','preliminary','partial'}       and exists("Initial Population")

//return the RSV DiagnosticReport based on the result pre admission define "SDE RSV DiagnosticReport Result from Lab":   "RSV DiagnosticReport Result from Lab" Reports     return SharedResource.DiagnosticReportLabResource(Reports,     {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-diagnosticreport-lab'}})

//---------------------------------- // SDE //---------------------------------- define "SDE IP Encounters":   "Initial Population" IP   return SharedResource.EncounterResource(IP,    {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-encounter'}})

//return the RSV Observation Pre Admission     define "SDE RSV PRE Admission Observation":   "RSV PRE Admission Observation" Observations     return SharedResource.ObservationLabResource(Observations,      {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-observation-lab'}})

define "SDE Isolation Precautions Implemented":   [Procedure: "Transmission Based Precaution Types"] IsolationPrecautions     where NHSNHelpers."Normalize Interval"(IsolationPrecautions.performed) during "Measurement Period"     and exists("Initial Population")   return SharedResource.ProcedureResource(IsolationPrecautions,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-procedure'}})

//further constrain COVID-19 and Influenza Observations for 14 day lookback define "COVID And Influenza PRE Admission Observation":   "COVID And Influenza Observation" O     where exists( EncounterInpatient E      where (       NHSNHelpers."Normalize Interval"(O.effective) 14 days or less on or before start of E.period       or NHSNHelpers."Normalize Interval"(GetSpecimen(O.specimen).collection.collected) 14 days or less on or before start of E.period       )       and start of E.period during "Measurement Period"     )

//return the Specimen related to the COVID-19 And Influenza Observation Pre Admission define "SDE COVID And Influenza Specimen":   "COVID And Influenza PRE Admission Observation" ObservationWithSpecimen     let Specimen: GetSpecimen(ObservationWithSpecimen.specimen)     return SharedResource.SpecimenResource(Specimen,     {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-specimen'}})

//To catch all isolation precautions define "SDE All ServiceRequests":   [ServiceRequest] SR   where exists("Initial Population")   return SharedResource.ServiceRequestResource(SR,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-servicerequest'}})

//return the COVID-19 And Influenza DiagnosticReport pre admission define "SDE COVID And Influenza DiagnosticReport":   "COVID And Influenza DiagnosticReport" Reports     return SharedResource.DiagnosticReportLabResource(Reports,     {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-diagnosticreport-lab'}})

//return the COVID-19 and Influenza Observation Pre Admission define "SDE COVID And Influenza PRE Admission Observation":   "COVID And Influenza PRE Admission Observation" Observations     return SharedResource.ObservationLabResource(Observations,     {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-observation-lab'}})

define "COVID and Influenza DiagnosticReport Observations":   "Observations" Observations   where Observations.code in "COVID_19 (Tests for SARS_CoV_2 Nucleic Acid)"     or Observations.code in "COVID_19 (Tests for SARS_CoV_2 Antigen)"     or Observations.code in "Influenza (Tests for influenza A or B virus Nucleic Acid)"     or Observations.code in "Influenza (Tests for influenza A or B virus Antigen)"

define "COVID and Influenza DiagnosticReport Result from Lab":   "DiagnosticReports" Reports     where exists(       "COVID and Influenza DiagnosticReport Observations" Observations       where Reports.result.references(Observations)     )     and Reports.status in {'final','registered','preliminary','partial'}     and exists("Initial Population")

define "ACH Daily DiagnosticReport Result from Lab":   "COVID and Influenza DiagnosticReport Result from Lab"     union "RSV DiagnosticReport Result from Lab"

//return the DiagnosticReport based on the result during the Measurement Period     define "SDE ACH Daily DiagnosticReport Result from Lab":   "ACH Daily DiagnosticReport Result from Lab" Reports     return SharedResource.DiagnosticReportLabResource(Reports,     {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-diagnosticreport-lab'}})

//return the COVID-19 and Influenza DiagnosticReport based on the result pre admission define "SDE COVID and Influenza DiagnosticReport Result from Lab":   "COVID and Influenza DiagnosticReport Result from Lab" Reports     return SharedResource.DiagnosticReportLabResource(Reports,     {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-diagnosticreport-lab'}})

define "SDE Location":   [Location] Locations   where exists("Initial Population")   return SharedResource.LocationResource(Locations,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-daily-location'}})

//----------------------------------------------------- //functions //----------------------------------------------------- define function "CheckIP"(encounter Encounter):   exists("Initial Population" IP   where encounter.id = IP.id)

define function ToString(value EncounterStatus): value.value

define function ToInterval(period FHIR.Period):     if period is null then         null      else          if period."start".value is null then             Interval(period."start".value, period."end".value]         else              if time from period."start".value is null and time from period."end".value is not null then                 Interval[                     DateTime(year from period."start".value, month from period."start".value, day from period."start".value,                         0, 0, 0, 0, timezoneoffset from period."end".value),                      period."end".value                 ]         else              if time from period."end".value is null and time from period."start".value is not null then                 Interval[                     period."start".value,                      DateTime(year from period."end".value, month from period."end".value, day from period."end".value,                         23, 59, 59, 999, timezoneoffset from period."start".value)                 ]         else Interval[period."start".value, period."end".value]

define function "GetLocation"(reference Reference ):   singleton from (  [Location] Locations   where Locations.id = GetId(reference.reference)   )

define function ToString(value string): value.value

define function "GetId"(uri String ):   Last(Split(uri, '/'))

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         }

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 EncounterResource(encounter Encounter, profileURLs List<FHIR.canonical>):   encounter e   return Encounter{     id: FHIR.id{value: 'LCR-' + e.id},     meta: MetaElement(e, profileURLs),     extension: e.extension,     identifier: EncounterIdentifier(e.identifier),     status: e.status,     statusHistory: EncounterStatusHistory(e.statusHistory),     class: e.class,     classHistory: EncounterClassHistory(e.classHistory),     type: e.type,     serviceType: e.serviceType,     priority: e.priority,     subject: e.subject,     period: e.period,     length: e.length,     reasonCode: e.reasonCode,     reasonReference: e.reasonReference,     diagnosis: EncounterDiagnosis(e.diagnosis),     account: e.account,     hospitalization: EncounterHospitalization(e.hospitalization),     location: EncounterLocation(e.location),     partOf: e.partOf   }

define function "MetaElement"(resource Resource, profileURLs List<FHIR.canonical>):   resource r   return FHIR.Meta{     extension: r.meta.extension,     versionId: r.meta.versionId,     lastUpdated: r.meta.lastUpdated,     profile: profileURLs,     security: r.meta.security,     tag: r.meta.tag   }

define function EncounterIdentifier(identifier List<FHIR.Identifier>):   identifier i   return FHIR.Identifier{     use: i.use,     type: i.type,     system: i.system,     value: i.value,     period: i.period   }

define function EncounterStatusHistory(statusHistory List<FHIR.Encounter.StatusHistory>):   statusHistory sH   return FHIR.Encounter.StatusHistory{     status: sH.status,     period: sH.period   }

define function EncounterClassHistory(classHistory List<FHIR.Encounter.ClassHistory>):   classHistory cH   return FHIR.Encounter.ClassHistory{     class: cH.class,     period: cH.period   }

/*No longer needed but saving for potential future use define function EncounterParticipant(participant List<FHIR.Encounter.Participant>):   participant p   return FHIR.Encounter.Participant{     type: p.type,     period: p.period,     individual: p.individual   }*/  define function EncounterDiagnosis(diagnosis List<FHIR.Encounter.Diagnosis>):   diagnosis d   return FHIR.Encounter.Diagnosis{     condition: d.condition,     use: d.use,     rank: d.rank   }

define function EncounterHospitalization(hospitalization FHIR.Encounter.Hospitalization):   hospitalization h   return FHIR.Encounter.Hospitalization{     preAdmissionIdentifier: h.preAdmissionIdentifier,     origin: h.origin,     admitSource: h.admitSource,     reAdmission: h.reAdmission,     dietPreference: h.dietPreference,     specialCourtesy: h.specialCourtesy,     specialArrangement: h.specialArrangement,     destination: h.destination,     dischargeDisposition: h.dischargeDisposition   }

define function EncounterLocation(location List<FHIR.Encounter.Location>):   location l   return FHIR.Encounter.Location{     location: l.location,     status: l.status,     physicalType: l.physicalType,     period: l.period   }

define function ToString(value ServiceRequestIntent): value.value

define function ToString(value ServiceRequestStatus): value.value

define function ServiceRequestResource(serviceRequest ServiceRequest, profileURLs List<FHIR.canonical>):   serviceRequest sR   return ServiceRequest{     id: FHIR.id {value: 'LCR-' + sR.id},     meta: MetaElement(sR, profileURLs),     extension: sR.extension,     instantiatesCanonical: sR.instantiatesCanonical,     instantiatesUri: sR.instantiatesUri,     basedOn: sR.basedOn,     replaces: sR.replaces,     requisition: sR.requisition,     status: sR.status,     intent: sR.intent,     category: sR.category,     priority: sR.priority,     doNotPerform: sR.doNotPerform,     code: sR.code,     orderDetail: sR.orderDetail,     quantity: sR.quantity,     subject: sR.subject,     encounter: sR.encounter,     occurrence: sR.occurrence,     asNeeded: sR.asNeeded,     authoredOn: sR.authoredOn,     requester: sR.requester,     performerType: sR.performerType,     performer: sR.performer,     locationCode: sR.locationCode,     locationReference: sR.locationReference,     reasonCode: sR.reasonCode,     reasonReference: sR.reasonReference,     insurance: sR.insurance,     supportingInfo: sR.supportingInfo,     specimen: sR.specimen,     bodySite: sR.bodySite,     note: sR.note,     patientInstruction: sR.patientInstruction,     relevantHistory: sR.relevantHistory   }

define function ToString(value ObservationStatus): value.value

define function "GetSpecimen"(reference FHIR.Reference):   singleton from (     [Specimen] Specimens     where Specimens.id = NHSNHelpers.GetId(reference.reference)   )

define function SpecimenResource(specimen Specimen, profileURLs List<FHIR.canonical>):   specimen s   return Specimen{     id: FHIR.id {value: 'LCR-' + s.id},     meta: MetaElement(s, profileURLs),     extension: s.extension,     identifier: s.identifier,     accessionIdentifier: s.accessionIdentifier,     status: s.status,     type: s.type,     subject: s.subject,     receivedTime: s.receivedTime,     parent: s.parent,     request: s.request,     collection: SpecimenCollection(s.collection),     processing: SpecimenProcessing(s.processing),     container: SpecimenContainer(s.container),     condition: s.condition,     note: s.note   }

define function SpecimenCollection(collection FHIR.Specimen.Collection):   collection c   return FHIR.Specimen.Collection{     collector: c.collector,     collected: c.collected,     "duration": c."duration",     quantity: c.quantity,     method: c.method,     bodySite: c.bodySite,     fastingStatus: c.fastingStatus   }

define function SpecimenProcessing(processing List<FHIR.Specimen.Processing>):   processing p   return FHIR.Specimen.Processing{     description: p.description,     procedure: p.procedure,     additive: p.additive,     time: p.time   }

define function SpecimenContainer(container List<FHIR.Specimen.Container>):   container c   return FHIR.Specimen.Container{     description: c.description,     type: c.type,     capacity: c.capacity,     specimenQuantity: c.specimenQuantity,     additive: c.additive   }

define function ToString(value DiagnosticReportStatus): value.value

define function DiagnosticReportLabResource(diagnosticReport DiagnosticReport, profileURLs List<FHIR.canonical>):   diagnosticReport d   return DiagnosticReport{     id: FHIR.id{value: 'LCR-' + d.id},     meta: MetaElement(d, profileURLs),     extension: d.extension,     basedOn: d.basedOn,     status: d.status,     category: DiagnosticReportCategory(d.category),     code: d.code,     subject: d.subject,     encounter: d.encounter,     effective: d.effective,     issued: d.issued,     performer: d.performer,     resultsInterpreter: d.resultsInterpreter,     specimen: d.specimen,     result: d.result,     conclusion: d.conclusion,     conclusionCode: d.conclusionCode   }

define function DiagnosticReportCategory(category List<CodeableConcept>):   category c   return CodeableConcept{     coding: DiagnosticReportCoding(c.coding)   }

define function DiagnosticReportCoding(coding List<Coding>):   coding c   return Coding{     system: c.system,     version: c.version,     code: c.code,     display: c.display,     userSelected: c.userSelected   }

define function ObservationLabResource(observation Observation, profileURLs List<FHIR.canonical>):   observation o   return Observation{     id: FHIR.id {value: 'LCR-' + o.id},     meta: MetaElement(o, profileURLs),     extension: o.extension,     basedOn: o.basedOn,     partOf: o.partOf,     status: o.status,     category: ObservationLabCategory(o.category),     code: o.code,     subject: o.subject,     focus: o.focus,     encounter: o.encounter,     effective: o.effective,     issued: o.issued,     performer: o.performer,     value: o.value,     dataAbsentReason: o.dataAbsentReason,     interpretation: o.interpretation,     note: o.note,     bodySite: o.bodySite,     method: o.method,     specimen: o.specimen,     device: o.device,     referenceRange: ObservationReferenceRange(o.referenceRange),     hasMember: o.hasMember,     derivedFrom: o.derivedFrom,     component: ObservationComponent(o.component)   }

define function ObservationLabCategory(category List<CodeableConcept>):   category c   return CodeableConcept{     coding: ObservationLabCoding(c.coding),     text: c.text   }

define function ObservationLabCoding(coding List<Coding>):   coding c   return Coding{     id: c.id,     extension: c.extension,     system: c.system,     version: c.version,     code: c.code,     display: c.display,     userSelected: c.userSelected   }

define function ObservationReferenceRange(referenceRange List<FHIR.Observation.ReferenceRange>):   referenceRange rR   return FHIR.Observation.ReferenceRange{     low: rR.low,     high: rR.high,     type: rR.type,     appliesTo: rR.appliesTo,     age: rR.age,     text: rR.text   }

define function ObservationComponent(component List<FHIR.Observation.Component>):   component c   return FHIR.Observation.Component{     code: c.code,     value: c.value,     dataAbsentReason: c.dataAbsentReason,     interpretation: c.interpretation,     referenceRange: c.referenceRange   }

define function ProcedureResource(procedure Procedure, profileURLs List<FHIR.canonical>):   procedure p   return Procedure{     id: FHIR.id {value: 'LCR-' + p.id},     meta: MetaElement(p, profileURLs),     extension: p.extension,     instantiatesCanonical: p.instantiatesCanonical,     instantiatesUri: p.instantiatesUri,     basedOn: p.basedOn,     partOf: p.partOf,     status: p.status,     statusReason: p.statusReason,     category: p.category,     code: p.code,     subject: p.subject,     encounter: p.encounter,     performed: p.performed,     recorder: p.recorder,     asserter: p.asserter,     performer: ProcedurePerformer(p.performer),     location: p.location,     reasonCode: p.reasonCode,     reasonReference: p.reasonReference,     bodySite: p.bodySite,     outcome: p.outcome,     report: p.report,     complication: p.complication,     complicationDetail: p.complicationDetail,     followUp: p.followUp,     note: p.note,     focalDevice: ProcedureFocalDevice(p.focalDevice),     usedReference: p.usedReference,     usedCode: p.usedCode   }

define function ProcedurePerformer(performer List<FHIR.Procedure.Performer>):   performer p   return FHIR.Procedure.Performer{     function: p.function,     actor: p.actor,     onBehalfOf: p.onBehalfOf   }

define function ProcedureFocalDevice(device List<FHIR.Procedure.FocalDevice>):   device d   return FHIR.Procedure.FocalDevice{     action: d.action,     manipulated: d.manipulated   }

define function "GetMedicationCode"(choice Choice<FHIR.CodeableConcept, FHIR.Reference>):   case     when choice is FHIR.CodeableConcept then       choice as FHIR.CodeableConcept     when choice is FHIR.Reference then       GetMedication(choice as FHIR.Reference).code     else       null as FHIR.CodeableConcept   end

define function "GetMedication"(reference Reference ):   singleton from (     [Medication: id in {NHSNHelpers.GetId(reference.reference)}]   )

define function "Normalize Interval"(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, '1', 'Error', 'Cannot compute a single interval from a Timing type')     when choice is FHIR.string then       Message(null as Interval<DateTime>, true, '1', 'Error', 'Cannot compute an interval from a String value')   else    null as Interval<DateTime>  end

define function ToDateTime(value dateTime): value.value

define function ToDateTime(value instant): value.value

define function ToDate(value date): value.value

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

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

//  // Measure Specific Resource Creation Functions  //  define function MedicationRequestResource(medicationRequest MedicationRequest, profileURLs List<FHIR.canonical>):   medicationRequest m   return MedicationRequest{     id: FHIR.id {value: 'LCR-' + m.id},     meta: SharedResource.MetaElement(medicationRequest, profileURLs),     extension: m.extension,     status: m.status,     intent: m.intent,     category: m.category,     priority: m.priority,     doNotPerform: m.doNotPerform,     reported: m.reported,     medication: m.medication,     subject: m.subject,     encounter: m.encounter,     authoredOn: m.authoredOn,     requester: m.requester,     recorder: m.recorder,     reasonCode: m.reasonCode,     reasonReference: m.reasonReference,     instantiatesCanonical: m.instantiatesCanonical,     instantiatesUri: m.instantiatesUri,     courseOfTherapyType: m.courseOfTherapyType,     dosageInstruction: SharedResource.MedicationRequestDosageInstruction(m.dosageInstruction)   }

define function MedicationRequestDosageInstruction(dosageInstruction List<FHIR.Dosage>):   dosageInstruction dI   return FHIR.Dosage{     text: dI.text,     patientInstruction: dI.patientInstruction,     timing: dI.timing,     asNeeded: dI.asNeeded,     site: dI.site,     route: dI.route,     method: dI.method,     doseAndRate: MedicationRequestDoseAndRate(dI.doseAndRate)   }

define function MedicationRequestDoseAndRate(doseAndRate List<FHIR.Dosage.DoseAndRate>):   doseAndRate dR   return FHIR.Dosage.DoseAndRate{     type: dR.type,     dose: dR.dose,     rate: dR.rate   }

define function PatientResource(patient Patient, profileURLs List<FHIR.canonical>):   patient p   return Patient{     id: FHIR.id{value: 'LCR-' + p.id},     meta: MetaElement(p, profileURLs),     extension: GetPatientExtensions(p) union GetIdExtensions(p),     identifier: p.identifier,     active: p.active,     name: PatientName(p.name),     telecom: PatientTelecom(p.telecom),     gender: p.gender,     birthDate: p.birthDate,     deceased: p.deceased,     address: PatientAddress(p.address),     maritalStatus: p.maritalStatus,     multipleBirth: p.multipleBirth,     photo: p.photo,     contact: PatientContact(p.contact),     communication: PatientCommunication(p.communication),     generalPractitioner: p.generalPractitioner,     managingOrganization: p.managingOrganization,     link: PatientLink(p.link)   }

define function "GetPatientExtensions"(domainResource DomainResource):   domainResource.extension E   where E.url.value = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-race'     or E.url.value = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity'     or E.url.value = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex'     or E.url.value = 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/link-original-resource-id-extension'   return E

define function "GetIdExtensions"(domainResource DomainResource):   domainResource.extension E   where E.url.value = 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/link-original-resource-id-extension'   return E

/* No longer needed but saving in case it's useful later define function PatientIdentifier(identifier List<FHIR.Identifier>):   identifier i   return FHIR.Identifier{     id: i.id,     extension: i.extension,     use: i.use,     type: i.type,     system: i.system,     value: i.value,     period: i.period,     assigner: i.assigner   }*/  define function PatientName(name List<FHIR.HumanName>):   name n   return FHIR.HumanName{     id: n.id,     extension: n.extension,     use: n.use,     text: n.text,     family: n.family,     given: n.given,     prefix: n.prefix,     suffix: n.suffix,     period: n.period   }

define function PatientTelecom(telecom List<FHIR.ContactPoint>):   telecom t   return FHIR.ContactPoint{     system: t.system,     value: t.value,     use: t.use,     rank: t.rank,     period: t.period   }

define function PatientAddress(address List<FHIR.Address>):   address a   return FHIR.Address{     id: a.id,     extension: a.extension,     use: a.use,     type: a.type,     text: a.text,     line: a.line,     city: a.city,     district: a.district,     state: a.state,     postalCode: a.postalCode,     country: a.country,     period: a.period   }

define function PatientContact(contact List<FHIR.Patient.Contact>):   contact c   return FHIR.Patient.Contact{     id: c.id,     extension: c.extension,     relationship: c.relationship,     name: c.name,     telecom: c.telecom,     address: c.address,     gender: c.gender,     organization: c.organization,     period: c.period   }

define function PatientCommunication(communication List<FHIR.Patient.Communication>):   communication c   return FHIR.Patient.Communication{     id: c.id,     extension: c.extension,     language: c.language,     preferred: c.preferred   }

define function PatientLink(link List<FHIR.Patient.Link>):   link l   return FHIR.Patient.Link{     id: l.id,     extension: l.extension,     modifierExtension: l.modifierExtension,     other: l.other,     type: l.type   }

define function ToString(value MedicationAdministrationStatus): value.value

define function MedicationAdministrationResource(medicationAdministration MedicationAdministration, profileURLs List<FHIR.canonical>):   medicationAdministration m   return MedicationAdministration{     id: FHIR.id {value: 'LCR-' + m.id},     meta: MetaElement(m, profileURLs),     extension: m.extension,     instantiates: m.instantiates,     partOf: m.partOf,     status: m.status,     statusReason: m.statusReason,     category: m.category,     medication: m.medication,     subject: m.subject,     context: m.context,     supportingInformation: m.supportingInformation,     effective: m.effective,     performer: MedicationAdministrationPerformer(m.performer),     reasonCode: m.reasonCode,     reasonReference: m.reasonReference,     request: m.request,     device: m.device,     note: m.note,     dosage: MedicationAdministrationDosage(m.dosage),     eventHistory: m.eventHistory   }

define function MedicationAdministrationPerformer(performer List<FHIR.MedicationAdministration.Performer>):   performer p   return FHIR.MedicationAdministration.Performer{     function: p.function,     actor: p.actor   }

define function MedicationAdministrationDosage(dosage FHIR.MedicationAdministration.Dosage):   dosage d   return FHIR.MedicationAdministration.Dosage{     text: d.text,     site: d.site,     route: d.route,     method: d.method,     dose: d.dose,     rate: d.rate   }

define function MedicationResource(medication Medication, profileURLs List<FHIR.canonical>):   medication m   return Medication{     id: FHIR.id {value: 'LCR-' + m.id},     meta: MetaElement(m, profileURLs),     extension: m.extension,     code: m.code,     status: m.status,     manufacturer: m.manufacturer,     form: m.form,     amount: m.amount,     ingredient: MedicationIngredient(m.ingredient),     batch: MedicationBatch(m.batch)   }

define function MedicationIngredient(ingredient List<FHIR.Medication.Ingredient>):   ingredient i   return FHIR.Medication.Ingredient{     item: i.item,     strength: i.strength   }

define function MedicationBatch(batch FHIR.Medication.Batch):   batch b   return FHIR.Medication.Batch{     lotNumber: b.lotNumber,     expirationDate: b.expirationDate   }

define function "GetMedicationFrom"(choice Choice<FHIR.CodeableConcept, FHIR.Reference>):   case     when choice is FHIR.Reference then       GetMedication(choice as FHIR.Reference)     else       null   end

define fluent function references(references List<FHIR.Reference>, resource FHIR.Resource):   exists(references R where R.references(resource))

define fluent function references(reference FHIR.Reference, resource FHIR.Resource):   resource.id = Last(Split(reference.reference, '/'))

define function LocationResource(location Location, profileURLs List<FHIR.canonical>):   location l   return Location{     id: FHIR.id {value: 'LCR-' + l.id},     meta: MetaElement(l, profileURLs),     extension: l.extension,     status: l.status,     operationalStatus: l.operationalStatus,     name: l.name,     alias: l.alias,     description: l.description,     mode: l.mode,     type: l.type,     telecom: l.telecom,     address: LocationAddress(l.address),     physicalType: l.physicalType,     position: LocationPosition(l.position),     managingOrganization: l.managingOrganization,     partOf: l.partOf,     hoursOfOperation: LocationHoursOfOperation(l.hoursOfOperation),     availabilityExceptions: l.availabilityExceptions,     endpoint: l.endpoint   }

define function LocationAddress(address FHIR.Address):   address a   return FHIR.Address{     use: a.use,     type: a.type,     text: a.text,     line: a.line,     city: a.city,     district: a.district,     state: a.state,     postalCode: a.postalCode,     country: a.country,     period: a.period   }

define function LocationPosition(position FHIR.Location.Position):   position p   return FHIR.Location.Position{     longitude: p.longitude,     latitude: p.latitude,     altitude: p.altitude   }

define function LocationHoursOfOperation(hoursOfOperation List<FHIR.Location.HoursOfOperation>):   hoursOfOperation hOO   return FHIR.Location.HoursOfOperation{     daysOfWeek: hOO.daysOfWeek,     allDay: hOO.allDay,     openingTime: hOO.openingTime,     closingTime: hOO.closingTime   }