define "Encounters":   [Encounter]

define "Qualifying Encounters During Measurement Period":  ( [Encounter: "Encounter Inpatient"]   union [Encounter: "Emergency Department Visit"]   union [Encounter: "Observation Services"]   union [Encounter: class in "NHSN Inpatient Encounter Class Codes"]   union [Encounter: class ~ "emergency"]   union [Encounter: class ~ "observation encounter"]) QualifyingEncounters   where QualifyingEncounters.status in {'in-progress', 'finished', 'triaged', 'onleave', 'entered-in-error'}     and QualifyingEncounters.period overlaps "Measurement Period"

define "Encounters with Patient Hospital Locations":   "Encounters" Encounters   where exists(     Encounters.location EncounterLocation     where NHSNHelpers.GetLocation(EncounterLocation.location).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"

define "Initial Population":   "Qualifying Encounters During Measurement Period"   union "Encounters with Patient Hospital Locations"

//#End DiagnosticReport block  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 Medication Request":   [MedicationRequest] MedicationRequests    where exists(     "Initial Population" IP     where MedicationRequests.authoredOn during IP.period)   return MedicationRequestResource(MedicationRequests,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-medicationrequest'}},   {"inpatient", "outpatient"})

define "SDE Coverage":   [Coverage] Coverages   where exists(     "Initial Population" IP     where Coverages.period overlaps IP.period)   return SharedResource.CoverageResource(Coverages,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-coverage'}})

define "SDE Procedure":   [Procedure] Procedures    where exists(     "Initial Population" IP     where NHSNHelpers."Normalize Interval"(Procedures.performed) overlaps IP.period)      return ProcedureResource(Procedures,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-procedure'}},   {"Surgical procedure", "Diagnostic procedure"})

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

define "SDE Device":   [Device] Devices    where exists("Initial Population")   return DeviceResource(Devices,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-device'}})

define "Observations":   [Observation]

define "SDE Observation Lab Category":   "Observations" Observations    where (exists(Observations.category Category where Category ~ "laboratory"))     and exists(       "Initial Population" IP       where NHSNHelpers."Normalize Interval"(Observations.effective) overlaps IP.period)   return ObservationLabResource(Observations,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-observation-lab'}},   {"imaging", "procedure", "vital-signs", "laboratory"})

//Vital Signs Observation has its own profile in FHIR Base define "SDE Observation Vital Signs Category":   "Observations" Observations    where (exists(Observations.category Category where Category ~ "vital-signs"))     and exists(       "Initial Population" IP       where NHSNHelpers."Normalize Interval"(Observations.effective) overlaps IP.period)   return ObservationVitalSignsResource(Observations,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-observation-vitals'}},   {"imaging", "procedure", "vital-signs", "laboratory"})

define "SDE DiagnosticReport Others":   [DiagnosticReport] DiagnosticReports   where not ((exists(DiagnosticReports.category Category where Category ~ "Radiology"))     or exists((DiagnosticReports.category Category where Category ~ "Pathology"))     or exists((DiagnosticReports.category Category where Category ~ "Cardiology"))     or exists(DiagnosticReports.category Category where Category ~ "LAB"))     and exists("Initial Population" IP       where NHSNHelpers."Normalize Interval"(DiagnosticReports.effective) overlaps IP.period)   return DiagnosticReportResource(DiagnosticReports,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-diagnosticreport'}})

define "SDE Medication Administration":   [MedicationAdministration] MedicationAdministrations    where exists(     "Initial Population" IP     where NHSNHelpers."Normalize Interval"(MedicationAdministrations.effective) overlaps IP.period)   return MedicationAdministrationResource(MedicationAdministrations,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-medicationadministration'}},   {"inpatient", "outpatient"})

//Defaulting to base FHIR profile as there are no individual profiles in US Core 3.1.1 that cover these Observation categories define "SDE Observation Category":   "Observations" Observations    where (/*(exists(Observations.category Category where Category ~ "social-history"))     or (exists(Observations.category Category where Category ~ "survey"))     or */(exists(Observations.category Category where Category ~ "imaging"))     or (exists(Observations.category Category where Category ~ "procedure")))     and exists(       "Initial Population" IP       where NHSNHelpers."Normalize Interval"(Observations.effective) overlaps IP.period)   return ObservationResource(Observations,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-observation'}},   {"imaging", "procedure", "vital-signs", "laboratory"})

define "Conditions":   [Condition]

//============================================================================ //Supplemental Data Element //When FHIR.canonical value is present, US Core 3.1.1 profiles are used //When FHIR.canonical value is not present, FHIR Base profiles are used //============================================================================ define "SDE Condition":   "Conditions" Conditions      where exists(     "Initial Population" IP //Check for Problem List Conditions that were recorded before or during IP       where        (exists(IP.diagnosis Diagnoses           where GetCondition(Diagnoses.condition).id = Conditions.id         )         or GetEncounter(Conditions.encounter).id = IP.id       )       and exists (Conditions.category categories         where categories ~ "encounter-diagnosis"     )   )   return ConditionResource(Conditions,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-condition'}},    {"encounter-diagnosis"})

define "DiagnosticReports":   [DiagnosticReport]

//This block collects all DiagnosticReport resources while also marking Lab and Note DiagnosticReports with the appropriate profiles //#Start DiagnosticReport block define "SDE DiagnosticReport Lab":   "DiagnosticReports" DiagnosticReports   where (exists(DiagnosticReports.category Category where Category ~ "LAB")     and exists(       "Initial Population" IP       where NHSNHelpers."Normalize Interval"(DiagnosticReports.effective) overlaps IP.period))   return DiagnosticReportLabResource(DiagnosticReports,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-diagnosticreport-lab'}},   {"LAB", "Radiology", "Pathology", "Cardiology"})

define "Get Locations from IP Encounters in Measurement Period":   flatten("Initial Population" IP   let locationElements: IP.location   return     locationElements LE     let locationReference: LE.location     return NHSNHelpers.GetLocation(locationReference))

define "SDE Location":   "Get Locations from IP Encounters in Measurement Period" Locations   where exists("Initial Population")   and Locations is not null   return SharedResource.LocationResource(Locations,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-location'}})

define "SDE Service Request":   [ServiceRequest] ServiceRequests   where exists("Initial Population" IP     where ServiceRequests.authoredOn during IP.period)   return ServiceRequestResource(ServiceRequests,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-servicerequest'}},   {"Laboratory procedure", "Surgical procedure", "Imaging"})

define "SDE DiagnosticReport Note":   "DiagnosticReports" DiagnosticReports   where ((exists(DiagnosticReports.category Category where Category ~ "Radiology"))     or exists((DiagnosticReports.category Category where Category ~ "Pathology"))     or exists((DiagnosticReports.category Category where Category ~ "Cardiology")))     and exists(       "Initial Population" IP       where NHSNHelpers."Normalize Interval"(DiagnosticReports.effective) overlaps IP.period)   return DiagnosticReportResource(DiagnosticReports,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-diagnosticreport-note'}})

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

define "SDE Medication":   ("SDE Medication Request"   union "SDE Medication Administration") MedReqOrAdmin   where MedReqOrAdmin.medication is FHIR.Reference   and exists("Initial Population") //No longer need to check for timing here because it's checked in SDE Medication Request/Administriation   return SharedResource.MedicationResource(GetMedicationFrom(MedReqOrAdmin.medication),   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-medication'}})

define "SDE Specimen":   [Specimen] Specimens   where exists(     "Initial Population" IP     where NHSNHelpers."Normalize Interval"(Specimens.collection.collected) overlaps IP.period   )   return SharedResource.SpecimenResource(Specimens,   {FHIR.canonical{value: 'http://www.cdc.gov/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-specimen'}})

// //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 ToDateTime(value dateTime): value.value

define function MedicationRequestResource(medicationRequest MedicationRequest, profileURLs List<FHIR.canonical>, acceptedCategories List<System.Code>):   medicationRequest m   return MedicationRequest{     id: FHIR.id {value: 'LCR-' + m.id},     meta: SharedResource.MetaElement(medicationRequest, profileURLs),     extension: m.extension,     status: m.status,     statusReason: m.statusReason,     intent: m.intent,     category: FilterCodeableConcepts(m.category, acceptedCategories),     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 FilterCodeableConcepts(codes List<FHIR.CodeableConcept>, accepted List<System.Code>):   if Count(accepted) > 0     then RemoveUnaccepted(codes, accepted)   else codes

define function RemoveUnaccepted(codes List<FHIR.CodeableConcept>, accepted List<System.Code>):   codes c   where exists(     accepted a     where c ~ a   )

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 CoverageResource(coverage Coverage, profileURLs List<FHIR.canonical>):   coverage c   return Coverage{     id: FHIR.id{value: 'LCR-' + c.id},     meta: MetaElement(c, profileURLs),     extension: c.extension,     status: c.status,     type: c.type,     policyHolder: c.policyHolder,     subscriber: c.subscriber,     subscriberId: c.subscriberId,     beneficiary: c.beneficiary,     dependent: c.dependent,     relationship: c.relationship,     period: c.period,     payor: c.payor,     class: CoverageClass(c.class),     order: c.order,     network: c.network,     subrogation: c.subrogation,     contract: c.contract   }

define function CoverageClass(class List<FHIR.Coverage.Class>):   class c   return FHIR.Coverage.Class{     value: c.value,     name: c.name   }

define function ProcedureResource(procedure Procedure, profileURLs List<FHIR.canonical>, acceptedCategories List<System.Code>):   procedure p   return Procedure{     id: FHIR.id {value: 'LCR-' + p.id},     meta: SharedResource.MetaElement(p, profileURLs),     extension: p.extension,     basedOn: p.basedOn,     partOf: p.partOf,     status: p.status,     category: FilterCodeableConcepts({p.category}, acceptedCategories)[0],     code: p.code,     subject: p.subject,     encounter: p.encounter,     performed: p.performed,     location: p.location,     reasonCode: p.reasonCode,     reasonReference: p.reasonReference,     bodySite: p.bodySite   }

define function DeviceResource(device Device, profileURLs List<FHIR.canonical>):   device d   return Device{     id: FHIR.id{value: 'LCR-' + d.id},     meta: SharedResource.MetaElement(d, profileURLs),     extension: d.extension,     status: d.status,     expirationDate: d.expirationDate,     lotNumber: d.lotNumber,     serialNumber: d.serialNumber,     modelNumber: d.modelNumber,     partNumber: d.partNumber,     type: d.type,     patient: d.patient,     parent: d.parent   }

define function ObservationLabResource(observation Observation, profileURLs List<FHIR.canonical>, acceptedCategories List<System.Code>):   observation o   return Observation{     id: FHIR.id {value: 'LCR-' + o.id},     meta: SharedResource.MetaElement(o, profileURLs),     extension: o.extension,     partOf: o.partOf,     status: o.status,     category: FilterCodeableConcepts(SharedResource.ObservationLabCategory(o.category), acceptedCategories),     code: o.code,     subject: o.subject,     encounter: o.encounter,     effective: o.effective,     issued: o.issued,     value: o.value,     dataAbsentReason: o.dataAbsentReason,     interpretation: o.interpretation,     bodySite: o.bodySite,     method: o.method,     specimen: o.specimen,     referenceRange: ObservationLabReferenceRange(o.referenceRange),     hasMember: o.hasMember,     derivedFrom: o.derivedFrom,     component: SharedResource.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 ObservationLabReferenceRange(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   }

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 ObservationVitalSignsResource(observation Observation, profileURLs List<FHIR.canonical>, acceptedCategories List<System.Code>):   observation o   return Observation{     id: FHIR.id {value: 'LCR-' + o.id},     meta: SharedResource.MetaElement(o, profileURLs),     extension: o.extension,     partOf: o.partOf,     status: o.status,     category: FilterCodeableConcepts(ObservationVitalSignsCategory(o.category), acceptedCategories),     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: SharedResource.ObservationReferenceRange(o.referenceRange),     hasMember: o.hasMember,     derivedFrom: o.derivedFrom,     component: ObservationVitalSignsComponent(o.component)   }

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

define function ObservationVitalSignsCoding(coding List<Coding>):   coding c   return Coding{     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 ObservationVitalSignsComponent(component List<FHIR.Observation.Component>):   component c   return FHIR.Observation.Component{     code: c.code,     value: c.value,     dataAbsentReason: c.dataAbsentReason,     interpretation: c.interpretation,     referenceRange: SharedResource.ObservationReferenceRange(c.referenceRange)   }

define function DiagnosticReportResource(diagnosticReport DiagnosticReport, profileURLs List<FHIR.canonical>):   diagnosticReport d   return DiagnosticReport{     id: FHIR.id{value: 'LCR-' + d.id},     meta: SharedResource.MetaElement(d, profileURLs),     extension: d.extension,     basedOn: d.basedOn,     status: d.status,     category: 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 MedicationAdministrationResource(medicationAdministration MedicationAdministration, profileURLs List<FHIR.canonical>, acceptedCategories List<System.Code>):   medicationAdministration m   return MedicationAdministration{     id: FHIR.id {value: 'LCR-' + m.id},     meta: SharedResource.MetaElement(m, profileURLs),     extension: m.extension,     instantiates: m.instantiates,     partOf: m.partOf,     status: m.status,     statusReason: m.statusReason,     category: FilterCodeableConcepts({m.category}, acceptedCategories)[0],     medication: m.medication,     subject: m.subject,     context: m.context,     supportingInformation: m.supportingInformation,     effective: m.effective,     performer: SharedResource.MedicationAdministrationPerformer(m.performer),     reasonCode: m.reasonCode,     reasonReference: m.reasonReference,     request: m.request,     device: m.device,     note: m.note,     dosage: SharedResource.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 ObservationResource(observation Observation, profileURLs List<FHIR.canonical>, acceptedCategories List<System.Code>):   observation o   return Observation{     id: FHIR.id {value: 'LCR-' + o.id},     meta: SharedResource.MetaElement(o, profileURLs),     extension: o.extension,     partOf: o.partOf,     status: o.status,     category: FilterCodeableConcepts(o.category, acceptedCategories),     code: o.code,     subject: o.subject,     encounter: o.encounter,     effective: o.effective,     issued: o.issued,     value: o.value,     dataAbsentReason: o.dataAbsentReason,     interpretation: o.interpretation,     bodySite: o.bodySite,     method: o.method,     specimen: o.specimen,     referenceRange: ObservationReferenceRange(o.referenceRange),     hasMember: o.hasMember,     derivedFrom: o.derivedFrom,     component: SharedResource.ObservationComponent(o.component)   }

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   }

define function "GetCondition"(reference Reference):   singleton from (     "Conditions" Conditions     where Conditions.id = NHSNHelpers.GetId(reference.reference)   )

define function "GetEncounter"(reference Reference):   singleton from (     "Encounters" Encounters     where Encounters.id = NHSNHelpers.GetId(reference.reference)   )

// //Measure Specific Resource Creation Functions //  define function ConditionResource(condition Condition, profileURLs List<FHIR.canonical>, acceptedCategories List<System.Code>):   condition c   return Condition{     id: FHIR.id {value: 'LCR-' + c.id},     meta: SharedResource.MetaElement(c, profileURLs),     extension: c.extension,     clinicalStatus: c.clinicalStatus,     verificationStatus: c.verificationStatus,     category: FilterCodeableConcepts(c.category, acceptedCategories),     code: c.code,     subject: c.subject,     encounter: c.encounter,     onset: c.onset,     abatement: c.abatement,     recordedDate: c.recordedDate   }

define function DiagnosticReportLabResource(diagnosticReport DiagnosticReport, profileURLs List<FHIR.canonical>, acceptedCategories List<System.Code>):   diagnosticReport d   return DiagnosticReport{     id: FHIR.id{value: 'LCR-' + d.id},     meta: SharedResource.MetaElement(d, profileURLs),     extension: d.extension,     basedOn: d.basedOn,     status: d.status,     category: FilterCodeableConcepts(DiagnosticReportCategory(d.category), acceptedCategories),     code: d.code,     subject: d.subject,     encounter: d.encounter,     effective: d.effective,     issued: d.issued,     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   }

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   }

define function ServiceRequestResource(serviceRequest ServiceRequest, profileURLs List<FHIR.canonical>, acceptedCategories List<System.Code>):   serviceRequest sR   return ServiceRequest{     id: FHIR.id {value: 'LCR-' + sR.id},     meta: SharedResource.MetaElement(sR, profileURLs),     extension: sR.extension,     basedOn: sR.basedOn,     status: sR.status,     intent: sR.intent,     category: FilterCodeableConcepts(sR.category, acceptedCategories),     priority: sR.priority,     doNotPerform: sR.doNotPerform,     code: sR.code,     quantity: sR.quantity,     subject: sR.subject,     encounter: sR.encounter,     occurrence: sR.occurrence,     asNeeded: sR.asNeeded,     authoredOn: sR.authoredOn,     requester: sR.requester,     specimen: sR.specimen   }

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 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 function "GetMedication"(reference Reference):   singleton from (     [Medication] Medications     where Medications.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   }