define "Initial Population":   [Encounter] QualifyingEncounters   where QualifyingEncounters.period overlaps "Measurement Period"

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: ''}})

define "SDE Medication Request":   [MedicationRequest] MedicationRequests    where exists(     "Initial Population" IP     where MedicationRequests.authoredOn during IP.period)   return MedicationRequestResource(MedicationRequests,   {FHIR.canonical{value: ''}})

define "SDE Coverage":   [Coverage] Coverages   where exists(     "Initial Population" IP     where Coverages.period overlaps IP.period)   return CoverageResource(Coverages,   {FHIR.canonical{value: ''}})

define "SDE IP Encounters":   "Initial Population" IP   return EncounterResource(IP,    {FHIR.canonical{value: ''}})

define "SDE Observation Lab Category":   [Observation] 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: ''}})

define "SDE Minimal Patient":   Patient p   return PatientResource(p,   {FHIR.canonical{value: ''}})

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 MedicationResource(GetMedicationFrom(MedReqOrAdmin.medication),   {FHIR.canonical{value: ''}})

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: ''}})

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 MedicationAdministrationResource(medicationAdministration MedicationAdministration, profileURLs List<FHIR.canonical>):   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: m.category,     medication: m.medication,     subject: m.subject,     context: m.context,     supportingInformation: m.supportingInformation,     effective: m.effective,     reasonCode: m.reasonCode,     reasonReference: m.reasonReference,     request: m.request,     dosage: MedicationAdministrationDosage(m.dosage),     eventHistory: m.eventHistory   }

define function ToString(value string): value.value

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 MedicationAdministrationDosage(dosage FHIR.MedicationAdministration.Dosage):   dosage d   return FHIR.MedicationAdministration.Dosage{     text: d.text,     route: d.route,     method: d.method,     dose: d.dose   }

define function ToDateTime(value dateTime): value.value

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,     statusReason: m.statusReason,     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: MedicationRequestDosageInstruction(m.dosageInstruction)   }

define function MedicationRequestDosageInstruction(dosageInstruction List<FHIR.Dosage>):   dosageInstruction dI   return FHIR.Dosage{     text: dI.text,     timing: dI.timing,     asNeeded: dI.asNeeded,     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   }

// //Measure Specific Resource Creation Functions // 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,     subscriber: c.subscriber,     period: c.period   }

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,     length: e.length,     reasonCode: e.reasonCode,     reasonReference: e.reasonReference,     hospitalization: EncounterHospitalization(e.hospitalization),     partOf: e.partOf   }

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   }

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

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 ObservationLabResource(observation Observation, profileURLs List<FHIR.canonical>):   observation o   return Observation{     id: FHIR.id {value: 'LCR-' + o.id},     meta: SharedResource.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: SharedResource.ObservationReferenceRange(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,     code: c.code   }

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 PatientResource(patient Patient, profileURLs List<FHIR.canonical>):   patient p   return Patient{     id: FHIR.id{value: 'LCR-' + p.id},     meta: SharedResource.MetaElement(p, profileURLs),     extension: GetPatientExtensions(p),     identifier: p.identifier,     active: p.active,     name: SharedResource.PatientName(p.name),     telecom: SharedResource.PatientTelecom(p.telecom),     gender: p.gender,     birthDate: p.birthDate,     deceased: p.deceased,     address: SharedResource.PatientAddress(p.address),     maritalStatus: p.maritalStatus,     multipleBirth: p.multipleBirth,     photo: p.photo,     contact: SharedResource.PatientContact(p.contact),     communication: SharedResource.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-tribal-affiliation'     or E.url.value = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex'     or E.url.value = 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-sex'   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{     id: l.id,     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: SharedResource.MetaElement(m, profileURLs),     extension: m.extension,     code: m.code,     status: m.status,     form: m.form,     amount: m.amount,     ingredient: SharedResource.MedicationIngredient(m.ingredient)   }

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

// //Functions // 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 "GetId"(uri String ):   Last(Split(uri, '/'))

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   }