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 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.cy118119.com/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 CoverageResource(Coverages,   {FHIR.canonical{value: 'http://www.cy118119.com/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.cy118119.com/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-procedure'}},   {"Surgical procedure", "Diagnostic intent (qualifier value)"})

define "SDE IP Encounters":   "Initial Population" IP   return EncounterResource(IP,    {FHIR.canonical{value: 'http://www.cy118119.com/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.cy118119.com/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.cy118119.com/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.cy118119.com/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-observation-vitals'}},   {"imaging", "procedure", "vital-signs", "laboratory"})

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.cy118119.com/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.cy118119.com/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 NHSNHelpers.GetId(Diagnoses.condition.reference) = Conditions.id         )         or NHSNHelpers.GetId(Conditions.encounter.reference) = IP.id       )       and exists (Conditions.category categories         where categories ~ "encounter-diagnosis"     )   )   return ConditionResource(Conditions,   {FHIR.canonical{value: 'http://www.cy118119.com/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.cy118119.com/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 LocationResource(Locations,   {FHIR.canonical{value: 'http://www.cy118119.com/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.cy118119.com/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.cy118119.com/nhsn/fhirportal/dqm/ig/StructureDefinition/ach-monthly-diagnosticreport-note'}},   {"Radiology", "Pathology", "Cardiology", "LAB"})

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

define "Medication IDs":   ("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 NHSNHelpers.GetId(MedReqOrAdmin.medication.reference)

define "SDE Medication":   [Medication] Medications   where Medications.id in "Medication IDs"   return SharedResource.MedicationResource(Medications,   {FHIR.canonical{value: 'http://www.cy118119.com/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 SpecimenResource(Specimens,   {FHIR.canonical{value: 'http://www.cy118119.com/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 "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: SharedResource.MetaElement(e, profileURLs),     extension: e.extension,     identifier: SharedResource.EncounterIdentifier(e.identifier),     status: e.status,     statusHistory: SharedResource.EncounterStatusHistory(e.statusHistory),     class: e.class,     classHistory: SharedResource.EncounterClassHistory(e.classHistory),     type: e.type,     subject: e.subject,     period: e.period,     reasonCode: e.reasonCode,     diagnosis: SharedResource.EncounterDiagnosis(e.diagnosis),     hospitalization: EncounterHospitalization(e.hospitalization),     location: SharedResource.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{     extension: h.extension,     origin: h.origin,     admitSource: h.admitSource,     reAdmission: h.reAdmission,     dietPreference: h.dietPreference,     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: SharedResource.MetaElement(c, profileURLs),     extension: c.extension,     status: c.status,     type: c.type,     beneficiary: c.beneficiary,     period: c.period,     payor: c.payor   }

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: GetProcedureExtensions(p),      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 "GetProcedureExtensions"(domainResource DomainResource):   domainResource.extension E     where E.url != 'http://hl7.org/fhir/us/qicore/StructureDefinition/qicore-recorded'      return E

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(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{     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,     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: ObservationVitalSignsReferenceRange(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 ObservationVitalSignsReferenceRange(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 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 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 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   }

// //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: SharedResource.MetaElement(l, profileURLs),     extension: l.extension,     status: l.status,     name: l.name,     alias: l.alias,     type: l.type,     physicalType: l.physicalType,     managingOrganization: l.managingOrganization,     partOf: l.partOf   }

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,     specimen: sR.specimen   }

define function DiagnosticReportResource(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(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 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),     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,     contact: PatientContact(p.contact),     communication: PatientCommunication(p.communication),     link: PatientLink(p.link)   }

define function "GetPatientExtensions"(domainResource DomainResource):   domainResource.extension E   where E.url = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-race'     or E.url = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity'     or E.url = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-tribal-affiliation'     or E.url = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex'     or E.url = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-sex'     or E.url = 'http://www.cy118119.com/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{     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{     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{     language: c.language,     preferred: c.preferred   }

define function PatientLink(link List<FHIR.Patient.Link>):   link l   return FHIR.Patient.Link{     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 SpecimenResource(specimen Specimen, profileURLs List<FHIR.canonical>):   specimen s   return Specimen{     id: FHIR.id {value: 'LCR-' + s.id},     meta: SharedResource.MetaElement(s, profileURLs),     extension: s.extension,     identifier: s.identifier,     accessionIdentifier: s.accessionIdentifier,     status: s.status,     type: s.type,     subject: s.subject,     parent: s.parent,     request: s.request,     collection: SpecimenCollection(s.collection),     note: s.note   }

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