From daa67f7e96c56f6833ffbc2be71b98accb931fd7 Mon Sep 17 00:00:00 2001 From: SevKohler Date: Thu, 9 Sep 2021 12:46:01 +0200 Subject: [PATCH 1/2] updated symptoms --- ...schlossenesSymptomEvaluationConverter.java | 6 +- .../symptom/SymptomCompositionConverter.java | 4 +- .../specific/symptom/SymptomConverter.java | 10 +- ...UnbekanntesSymptomEvaluationConverter.java | 7 +- ...rliegendesSymptomObservationConverter.java | 27 +- .../SymptomComposition.java | 576 +- .../SymptomCompositionContainment.java | 4 +- .../AusgeschlossenesSymptomEvaluation.java | 33 +- ...hlossenesSymptomEvaluationContainment.java | 5 +- .../AussageUberDenAusschlussDefiningCode.java | 52 - ...AussageUeberDenAusschlussDefiningCode.java | 40 + ...berDieFehlendeInformationDefiningCode.java | 40 + .../definition/DefiningCode.java | 51 - .../definition/KategorieDefiningCode.java | 39 + .../KategorieDefiningCodeSymptom.java | 51 - .../definition/KrankheitsanzeichenCode.java | 140 - ...ptomsKrankheitsanzeichensDefiningCode.java | 129 + .../definition/SchweregradDefiningCode.java | 56 + .../definition/SchweregradSymptomCode.java | 68 - ...ageUeberDieFehlendeInformationElement.java | 13 +- .../UnbekanntesSymptomEvaluation.java | 18 +- ...bekanntesSymptomEvaluationContainment.java | 3 +- ...SymptomAnatomischeLokalisationElement.java | 4 +- .../VorliegendesSymptomObservation.java | 32 +- ...iegendesSymptomObservationContainment.java | 5 +- src/main/resources/opt/Symptom.opt | 5105 +++--- .../profiles/SymptomsCovid19-profile.xml | 14842 ++++++++-------- 27 files changed, 10626 insertions(+), 10734 deletions(-) delete mode 100644 src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AussageUberDenAusschlussDefiningCode.java create mode 100644 src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AussageUeberDenAusschlussDefiningCode.java create mode 100644 src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AussageUeberDieFehlendeInformationDefiningCode.java delete mode 100644 src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/DefiningCode.java create mode 100644 src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/KategorieDefiningCode.java delete mode 100644 src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/KategorieDefiningCodeSymptom.java delete mode 100644 src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/KrankheitsanzeichenCode.java create mode 100644 src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/NameDesSymptomsKrankheitsanzeichensDefiningCode.java create mode 100644 src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/SchweregradDefiningCode.java delete mode 100644 src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/SchweregradSymptomCode.java diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/AusgeschlossenesSymptomEvaluationConverter.java b/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/AusgeschlossenesSymptomEvaluationConverter.java index b7f43f648..eb43c2440 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/AusgeschlossenesSymptomEvaluationConverter.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/AusgeschlossenesSymptomEvaluationConverter.java @@ -18,7 +18,7 @@ import org.ehrbase.fhirbridge.ehr.converter.generic.EntryEntityConverter; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.AusgeschlossenesSymptomEvaluation; -import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.AussageUberDenAusschlussDefiningCode; +import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.AussageUeberDenAusschlussDefiningCode; import org.hl7.fhir.r4.model.Condition; @SuppressWarnings("java:6212") @@ -29,8 +29,8 @@ public class AusgeschlossenesSymptomEvaluationConverter @Override protected AusgeschlossenesSymptomEvaluation convertInternal(Condition condition) { AusgeschlossenesSymptomEvaluation result = new AusgeschlossenesSymptomEvaluation(); - result.setAussageUeberDenAusschluss(AussageUberDenAusschlussDefiningCode.N410594000.toDvCodedText()); - result.setProblemDiagnose(convertCode(condition)); + result.setAussageUeberDenAusschlussDefiningCode(AussageUeberDenAusschlussDefiningCode.KNOWN_ABSENT_QUALIFIER_VALUE); + result.setProblemDiagnoseDefiningCode(convertCode(condition)); return result; } } diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/SymptomCompositionConverter.java b/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/SymptomCompositionConverter.java index e7b51d92d..58b8e74d1 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/SymptomCompositionConverter.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/SymptomCompositionConverter.java @@ -18,7 +18,7 @@ import org.ehrbase.fhirbridge.ehr.converter.generic.ConditionToCompositionConverter; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.SymptomComposition; -import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.KategorieDefiningCodeSymptom; +import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.KategorieDefiningCode; import org.hl7.fhir.r4.model.Condition; import org.hl7.fhir.r4.model.codesystems.ConditionVerStatus; import org.springframework.lang.NonNull; @@ -37,7 +37,7 @@ public class SymptomCompositionConverter extends ConditionToCompositionConverter @Override public SymptomComposition convertInternal(@NonNull Condition condition) { SymptomComposition result = new SymptomComposition(); - result.setKategorie(KategorieDefiningCodeSymptom.N753251.toDvCodedText()); + result.setKategorieDefiningCode(KategorieDefiningCode.SYMPTOM); Optional conditionVerStatus = resolveConditionVerStatus(condition); if (conditionVerStatus.isPresent() && conditionVerStatus.get() == ConditionVerStatus.CONFIRMED) { diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/SymptomConverter.java b/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/SymptomConverter.java index c7f4c0bb5..927abdfba 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/SymptomConverter.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/SymptomConverter.java @@ -1,21 +1,19 @@ package org.ehrbase.fhirbridge.ehr.converter.specific.symptom; -import com.nedap.archie.rm.datavalues.DvCodedText; import org.ehrbase.fhirbridge.ehr.converter.ConversionException; import org.ehrbase.fhirbridge.ehr.converter.specific.CodeSystem; -import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.KrankheitsanzeichenCode; +import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.NameDesSymptomsKrankheitsanzeichensDefiningCode; import org.hl7.fhir.r4.model.Condition; public interface SymptomConverter { - default DvCodedText convertCode(Condition condition) { + default NameDesSymptomsKrankheitsanzeichensDefiningCode convertCode(Condition condition) { return condition.getCode() .getCoding() .stream() .filter(coding -> coding.getSystem().equals(CodeSystem.SNOMED.getUrl())) .findFirst() - .map(coding -> KrankheitsanzeichenCode.getCodesAsMap().get(coding.getCode())) - .orElseThrow(() -> new ConversionException("Unbekanntes ")) - .toDvCodedText(); + .map(coding -> NameDesSymptomsKrankheitsanzeichensDefiningCode.getCodesAsMap().get(coding.getCode())) + .orElseThrow(() -> new ConversionException("Unbekanntes ")); } } diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/UnbekanntesSymptomEvaluationConverter.java b/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/UnbekanntesSymptomEvaluationConverter.java index 2286c9421..5cf71905f 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/UnbekanntesSymptomEvaluationConverter.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/UnbekanntesSymptomEvaluationConverter.java @@ -17,7 +17,7 @@ package org.ehrbase.fhirbridge.ehr.converter.specific.symptom; import org.ehrbase.fhirbridge.ehr.converter.generic.EntryEntityConverter; -import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.DefiningCode; +import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.AussageUeberDieFehlendeInformationDefiningCode; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.UnbekanntesSymptomAussageUeberDieFehlendeInformationElement; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.UnbekanntesSymptomEvaluation; import org.hl7.fhir.r4.model.Condition; @@ -31,10 +31,9 @@ public class UnbekanntesSymptomEvaluationConverter extends EntryEntityConverter< @Override protected UnbekanntesSymptomEvaluation convertInternal(Condition condition) { UnbekanntesSymptomEvaluation result = new UnbekanntesSymptomEvaluation(); - result.setUnbekanntesSymptom(convertCode(condition)); - + result.setUnbekanntesSymptomDefiningCode(convertCode(condition)); UnbekanntesSymptomAussageUeberDieFehlendeInformationElement element = new UnbekanntesSymptomAussageUeberDieFehlendeInformationElement(); - element.setValue(DefiningCode.N261665006.toDvCodedText()); + element.setValue(AussageUeberDieFehlendeInformationDefiningCode.UNKNOWN_QUALIFIER_VALUE); result.setAussageUeberDieFehlendeInformation(Collections.singletonList(element)); return result; diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/VorliegendesSymptomObservationConverter.java b/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/VorliegendesSymptomObservationConverter.java index d177592ce..8f1f4e8a0 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/VorliegendesSymptomObservationConverter.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/converter/specific/symptom/VorliegendesSymptomObservationConverter.java @@ -16,13 +16,10 @@ package org.ehrbase.fhirbridge.ehr.converter.specific.symptom; -import com.nedap.archie.rm.datavalues.DvCodedText; -import org.ehrbase.fhirbridge.ehr.converter.ConversionException; import org.ehrbase.fhirbridge.ehr.converter.generic.ConditionToObservationConverter; import org.ehrbase.fhirbridge.ehr.converter.generic.TimeConverter; import org.ehrbase.fhirbridge.ehr.converter.specific.CodeSystem; -import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.KrankheitsanzeichenCode; -import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.SchweregradSymptomCode; +import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.SchweregradDefiningCode; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.VorliegendesSymptomAnatomischeLokalisationElement; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.VorliegendesSymptomObservation; import org.hl7.fhir.r4.model.Condition; @@ -34,30 +31,19 @@ import java.util.stream.Collectors; @SuppressWarnings("java:S6212") -public class VorliegendesSymptomObservationConverter extends ConditionToObservationConverter { +public class VorliegendesSymptomObservationConverter extends ConditionToObservationConverter implements SymptomConverter { @Override protected VorliegendesSymptomObservation convertInternal(Condition condition) { VorliegendesSymptomObservation result = new VorliegendesSymptomObservation(); - result.setNameDesSymptomsKrankheitsanzeichens(convertCode(condition)); + result.setNameDesSymptomsKrankheitsanzeichensDefiningCode(convertCode(condition)); result.setAnatomischeLokalisation(convertBodySites(condition)); result.setBeginnDerEpisodeValue(TimeConverter.convertConditionOnset(condition)); - convertSeverity(condition).ifPresent(result::setSchweregrad); + convertSeverity(condition).ifPresent(result::setSchweregradDefiningCode); TimeConverter.convertConditionAbatementTime(condition).ifPresent(result::setDatumUhrzeitDesRueckgangsValue); return result; } - private DvCodedText convertCode(Condition condition) { - return condition.getCode() - .getCoding() - .stream() - .filter(coding -> coding.getSystem().equals(CodeSystem.SNOMED.getUrl())) - .findFirst() - .map(coding -> KrankheitsanzeichenCode.getCodesAsMap().get(coding.getCode())) - .orElseThrow(() -> new ConversionException("Unbekanntes ")) - .toDvCodedText(); - } - private List convertBodySites(Condition condition) { if (!condition.hasBodySite()) { return new ArrayList<>(); @@ -74,7 +60,7 @@ private List convertBodySites .collect(Collectors.toList()); } - private Optional convertSeverity(Condition condition) { + private Optional convertSeverity(Condition condition) { if (!condition.hasSeverity()) { return Optional.empty(); } @@ -84,7 +70,6 @@ private Optional convertSeverity(Condition condition) { .stream() .filter(coding -> Objects.equals(coding.getSystem(), CodeSystem.SNOMED.getUrl())) .findFirst() - .map(coding -> SchweregradSymptomCode.getCodesAsMap().get(coding.getCode())) - .map(SchweregradSymptomCode::toDvCodedText); + .map(coding -> SchweregradDefiningCode.getCodesAsMap().get(coding.getCode())); } } diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/SymptomComposition.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/SymptomComposition.java index 3884f9356..bbece1d69 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/SymptomComposition.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/SymptomComposition.java @@ -2,10 +2,13 @@ import com.nedap.archie.rm.archetyped.FeederAudit; import com.nedap.archie.rm.datastructures.Cluster; -import com.nedap.archie.rm.datavalues.DvCodedText; import com.nedap.archie.rm.generic.Participation; import com.nedap.archie.rm.generic.PartyIdentified; import com.nedap.archie.rm.generic.PartyProxy; +import java.lang.String; +import java.time.temporal.TemporalAccessor; +import java.util.List; +import javax.annotation.processing.Generated; import org.ehrbase.client.annotations.Archetype; import org.ehrbase.client.annotations.Entity; import org.ehrbase.client.annotations.Id; @@ -19,304 +22,301 @@ import org.ehrbase.client.classgenerator.shareddefinition.Territory; import org.ehrbase.client.openehrclient.VersionUid; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.AusgeschlossenesSymptomEvaluation; +import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.KategorieDefiningCode; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.StatusDefiningCode; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.UnbekanntesSymptomEvaluation; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.VorliegendesSymptomObservation; -import javax.annotation.processing.Generated; -import java.time.temporal.TemporalAccessor; -import java.util.List; - @Entity @Archetype("openEHR-EHR-COMPOSITION.registereintrag.v1") @Generated( - value = "org.ehrbase.client.classgenerator.ClassGenerator", - date = "2021-03-09T14:41:23.600340+01:00", - comments = "https://github.com/ehrbase/openEHR_SDK Version: 1.3.0" + value = "org.ehrbase.client.classgenerator.ClassGenerator", + date = "2021-09-09T12:22:43.822251+02:00", + comments = "https://github.com/ehrbase/openEHR_SDK Version: 1.5.0" ) @Template("Symptom") public class SymptomComposition implements CompositionEntity { - /** - * Path: COVID-19 Symptom/category - */ - @Path("/category|defining_code") - private Category categoryDefiningCode; - - /** - * Path: COVID-19 Symptom/context/Erweiterung - * Description: Ergänzende Angaben zum Registereintrag. - */ - @Path("/context/other_context[at0001]/items[at0002]") - private List erweiterung; - - /** - * Path: COVID-19 Symptom/context/Status - * Description: Status der gelieferten Daten für den Registereintrag. Hinweis: Dies ist nicht der Status einzelner Komponenten. - */ - @Path("/context/other_context[at0001]/items[at0004]/value|defining_code") - private StatusDefiningCode statusDefiningCode; - - /** - * Path: COVID-19 Symptom/context/Baum/Status/null_flavour - */ - @Path("/context/other_context[at0001]/items[at0004]/null_flavour|defining_code") - private NullFlavour statusNullFlavourDefiningCode; - - /** - * Path: COVID-19 Symptom/context/Kategorie - * Description: Die Klassifikation des Registereintrags (z.B. Typ der Observation des FHIR-Profils). - */ - @Path("/context/other_context[at0001]/items[at0005]/value") - private DvCodedText kategorie; - - /** - * Path: COVID-19 Symptom/context/Baum/Kategorie/null_flavour - */ - @Path("/context/other_context[at0001]/items[at0005]/null_flavour|defining_code") - private NullFlavour kategorieNullFlavourDefiningCode; - - /** - * Path: COVID-19 Symptom/context/start_time - */ - @Path("/context/start_time|value") - private TemporalAccessor startTimeValue; - - /** - * Path: COVID-19 Symptom/context/participations - */ - @Path("/context/participations") - private List participations; - - /** - * Path: COVID-19 Symptom/context/end_time - */ - @Path("/context/end_time|value") - private TemporalAccessor endTimeValue; - - /** - * Path: COVID-19 Symptom/context/location - */ - @Path("/context/location") - private String location; - - /** - * Path: COVID-19 Symptom/context/health_care_facility - */ - @Path("/context/health_care_facility") - private PartyIdentified healthCareFacility; - - /** - * Path: COVID-19 Symptom/context/setting - */ - @Path("/context/setting|defining_code") - private Setting settingDefiningCode; - - /** - * Path: COVID-19 Symptom/Vorliegendes Symptom - * Description: Festgestellte Beobachtung einer körperlichen oder geistigen Störung bei einer Person. - */ - @Path("/content[openEHR-EHR-OBSERVATION.symptom_sign.v0 and name/value='Vorliegendes Symptom']") - private VorliegendesSymptomObservation vorliegendesSymptom; - - /** - * Path: COVID-19 Symptom/Ausgeschlossenes Symptom - * Description: Ein Bericht über den Ausschluss eines/r Problems/Diagnose, familiäre Krankengeschichte, Medikation, Nebenwirkung/Allergens oder eines anderen klinischen Ereignisses, welche/s zur Zeit nicht oder noch nie vorhanden war. - */ - @Path("/content[openEHR-EHR-EVALUATION.exclusion_specific.v1 and name/value='Ausgeschlossenes Symptom']") - private AusgeschlossenesSymptomEvaluation ausgeschlossenesSymptom; - - /** - * Path: COVID-19 Symptom/Unbekanntes Symptom - * Description: Aussage darüber, dass bestimmte Gesundheitsinformationen zum Zeitpukt der Erfassung nicht in der Krankenakte oder einem Schriftstück erfasst werden können, da keine Kenntnisse darüber vorhanden sind. - */ - @Path("/content[openEHR-EHR-EVALUATION.absence.v2 and name/value='Unbekanntes Symptom']") - private UnbekanntesSymptomEvaluation unbekanntesSymptom; - - /** - * Path: COVID-19 Symptom/composer - */ - @Path("/composer") - private PartyProxy composer; - - /** - * Path: COVID-19 Symptom/language - */ - @Path("/language") - private Language language; - - /** - * Path: COVID-19 Symptom/feeder_audit - */ - @Path("/feeder_audit") - private FeederAudit feederAudit; - - /** - * Path: COVID-19 Symptom/territory - */ - @Path("/territory") - private Territory territory; - - @Id - private VersionUid versionUid; - - public Category getCategoryDefiningCode() { - return this.categoryDefiningCode; - } - - public void setCategoryDefiningCode(Category categoryDefiningCode) { - this.categoryDefiningCode = categoryDefiningCode; - } - - public List getErweiterung() { - return this.erweiterung; - } - - public void setErweiterung(List erweiterung) { - this.erweiterung = erweiterung; - } - - public StatusDefiningCode getStatusDefiningCode() { - return this.statusDefiningCode; - } - - public void setStatusDefiningCode(StatusDefiningCode statusDefiningCode) { - this.statusDefiningCode = statusDefiningCode; - } - - public NullFlavour getStatusNullFlavourDefiningCode() { - return this.statusNullFlavourDefiningCode; - } - - public void setStatusNullFlavourDefiningCode(NullFlavour statusNullFlavourDefiningCode) { - this.statusNullFlavourDefiningCode = statusNullFlavourDefiningCode; - } - - public DvCodedText getKategorie() { - return this.kategorie; - } - - public void setKategorie(DvCodedText kategorie) { - this.kategorie = kategorie; - } - - public NullFlavour getKategorieNullFlavourDefiningCode() { - return this.kategorieNullFlavourDefiningCode; - } - - public void setKategorieNullFlavourDefiningCode(NullFlavour kategorieNullFlavourDefiningCode) { - this.kategorieNullFlavourDefiningCode = kategorieNullFlavourDefiningCode; - } - - public TemporalAccessor getStartTimeValue() { - return this.startTimeValue; - } - - public void setStartTimeValue(TemporalAccessor startTimeValue) { - this.startTimeValue = startTimeValue; - } - - public List getParticipations() { - return this.participations; - } - - public void setParticipations(List participations) { - this.participations = participations; - } - - public TemporalAccessor getEndTimeValue() { - return this.endTimeValue; - } - - public void setEndTimeValue(TemporalAccessor endTimeValue) { - this.endTimeValue = endTimeValue; - } - - public String getLocation() { - return this.location; - } - - public void setLocation(String location) { - this.location = location; - } - - public PartyIdentified getHealthCareFacility() { - return this.healthCareFacility; - } - - public void setHealthCareFacility(PartyIdentified healthCareFacility) { - this.healthCareFacility = healthCareFacility; - } - - public Setting getSettingDefiningCode() { - return this.settingDefiningCode; - } - - public void setSettingDefiningCode(Setting settingDefiningCode) { - this.settingDefiningCode = settingDefiningCode; - } - - public VorliegendesSymptomObservation getVorliegendesSymptom() { - return this.vorliegendesSymptom; - } + /** + * Path: COVID-19 Symptom/category + */ + @Path("/category|defining_code") + private Category categoryDefiningCode; + + /** + * Path: COVID-19 Symptom/context/Erweiterung + * Description: Ergänzende Angaben zum Registereintrag. + */ + @Path("/context/other_context[at0001]/items[at0002]") + private List erweiterung; + + /** + * Path: COVID-19 Symptom/context/Status + * Description: Status der gelieferten Daten für den Registereintrag. Hinweis: Dies ist nicht der Status einzelner Komponenten. + */ + @Path("/context/other_context[at0001]/items[at0004]/value|defining_code") + private StatusDefiningCode statusDefiningCode; + + /** + * Path: COVID-19 Symptom/context/Baum/Status/null_flavour + */ + @Path("/context/other_context[at0001]/items[at0004]/null_flavour|defining_code") + private NullFlavour statusNullFlavourDefiningCode; + + /** + * Path: COVID-19 Symptom/context/Kategorie + * Description: Die Klassifikation des Registereintrags (z.B. Typ der Observation des FHIR-Profils). + */ + @Path("/context/other_context[at0001]/items[at0005]/value|defining_code") + private KategorieDefiningCode kategorieDefiningCode; + + /** + * Path: COVID-19 Symptom/context/Baum/Kategorie/null_flavour + */ + @Path("/context/other_context[at0001]/items[at0005]/null_flavour|defining_code") + private NullFlavour kategorieNullFlavourDefiningCode; + + /** + * Path: COVID-19 Symptom/context/start_time + */ + @Path("/context/start_time|value") + private TemporalAccessor startTimeValue; + + /** + * Path: COVID-19 Symptom/context/participations + */ + @Path("/context/participations") + private List participations; + + /** + * Path: COVID-19 Symptom/context/end_time + */ + @Path("/context/end_time|value") + private TemporalAccessor endTimeValue; + + /** + * Path: COVID-19 Symptom/context/location + */ + @Path("/context/location") + private String location; + + /** + * Path: COVID-19 Symptom/context/health_care_facility + */ + @Path("/context/health_care_facility") + private PartyIdentified healthCareFacility; + + /** + * Path: COVID-19 Symptom/context/setting + */ + @Path("/context/setting|defining_code") + private Setting settingDefiningCode; + + /** + * Path: COVID-19 Symptom/Vorliegendes Symptom + * Description: Festgestellte Beobachtung einer körperlichen oder geistigen Störung bei einer Person. + */ + @Path("/content[openEHR-EHR-OBSERVATION.symptom_sign.v0 and name/value='Vorliegendes Symptom']") + private VorliegendesSymptomObservation vorliegendesSymptom; + + /** + * Path: COVID-19 Symptom/Ausgeschlossenes Symptom + * Description: Ein Bericht über den Ausschluss eines/r Problems/Diagnose, familiäre Krankengeschichte, Medikation, Nebenwirkung/Allergens oder eines anderen klinischen Ereignisses, welche/s zur Zeit nicht oder noch nie vorhanden war. + */ + @Path("/content[openEHR-EHR-EVALUATION.exclusion_specific.v1 and name/value='Ausgeschlossenes Symptom']") + private AusgeschlossenesSymptomEvaluation ausgeschlossenesSymptom; + + /** + * Path: COVID-19 Symptom/Unbekanntes Symptom + * Description: Aussage darüber, dass bestimmte Gesundheitsinformationen zum Zeitpukt der Erfassung nicht in der Krankenakte oder einem Schriftstück erfasst werden können, da keine Kenntnisse darüber vorhanden sind. + */ + @Path("/content[openEHR-EHR-EVALUATION.absence.v2 and name/value='Unbekanntes Symptom']") + private UnbekanntesSymptomEvaluation unbekanntesSymptom; + + /** + * Path: COVID-19 Symptom/composer + */ + @Path("/composer") + private PartyProxy composer; + + /** + * Path: COVID-19 Symptom/language + */ + @Path("/language") + private Language language; + + /** + * Path: COVID-19 Symptom/feeder_audit + */ + @Path("/feeder_audit") + private FeederAudit feederAudit; + + /** + * Path: COVID-19 Symptom/territory + */ + @Path("/territory") + private Territory territory; + + @Id + private VersionUid versionUid; + + public void setCategoryDefiningCode(Category categoryDefiningCode) { + this.categoryDefiningCode = categoryDefiningCode; + } + + public Category getCategoryDefiningCode() { + return this.categoryDefiningCode ; + } + + public void setErweiterung(List erweiterung) { + this.erweiterung = erweiterung; + } + + public List getErweiterung() { + return this.erweiterung ; + } + + public void setStatusDefiningCode(StatusDefiningCode statusDefiningCode) { + this.statusDefiningCode = statusDefiningCode; + } + + public StatusDefiningCode getStatusDefiningCode() { + return this.statusDefiningCode ; + } + + public void setStatusNullFlavourDefiningCode(NullFlavour statusNullFlavourDefiningCode) { + this.statusNullFlavourDefiningCode = statusNullFlavourDefiningCode; + } + + public NullFlavour getStatusNullFlavourDefiningCode() { + return this.statusNullFlavourDefiningCode ; + } + + public void setKategorieDefiningCode(KategorieDefiningCode kategorieDefiningCode) { + this.kategorieDefiningCode = kategorieDefiningCode; + } + + public KategorieDefiningCode getKategorieDefiningCode() { + return this.kategorieDefiningCode ; + } + + public void setKategorieNullFlavourDefiningCode(NullFlavour kategorieNullFlavourDefiningCode) { + this.kategorieNullFlavourDefiningCode = kategorieNullFlavourDefiningCode; + } + + public NullFlavour getKategorieNullFlavourDefiningCode() { + return this.kategorieNullFlavourDefiningCode ; + } + + public void setStartTimeValue(TemporalAccessor startTimeValue) { + this.startTimeValue = startTimeValue; + } + + public TemporalAccessor getStartTimeValue() { + return this.startTimeValue ; + } + + public void setParticipations(List participations) { + this.participations = participations; + } + + public List getParticipations() { + return this.participations ; + } + + public void setEndTimeValue(TemporalAccessor endTimeValue) { + this.endTimeValue = endTimeValue; + } + + public TemporalAccessor getEndTimeValue() { + return this.endTimeValue ; + } + + public void setLocation(String location) { + this.location = location; + } + + public String getLocation() { + return this.location ; + } + + public void setHealthCareFacility(PartyIdentified healthCareFacility) { + this.healthCareFacility = healthCareFacility; + } + + public PartyIdentified getHealthCareFacility() { + return this.healthCareFacility ; + } + + public void setSettingDefiningCode(Setting settingDefiningCode) { + this.settingDefiningCode = settingDefiningCode; + } + + public Setting getSettingDefiningCode() { + return this.settingDefiningCode ; + } - public void setVorliegendesSymptom(VorliegendesSymptomObservation vorliegendesSymptom) { - this.vorliegendesSymptom = vorliegendesSymptom; - } + public void setVorliegendesSymptom(VorliegendesSymptomObservation vorliegendesSymptom) { + this.vorliegendesSymptom = vorliegendesSymptom; + } - public AusgeschlossenesSymptomEvaluation getAusgeschlossenesSymptom() { - return this.ausgeschlossenesSymptom; - } + public VorliegendesSymptomObservation getVorliegendesSymptom() { + return this.vorliegendesSymptom ; + } - public void setAusgeschlossenesSymptom( - AusgeschlossenesSymptomEvaluation ausgeschlossenesSymptom) { - this.ausgeschlossenesSymptom = ausgeschlossenesSymptom; - } - - public UnbekanntesSymptomEvaluation getUnbekanntesSymptom() { - return this.unbekanntesSymptom; - } - - public void setUnbekanntesSymptom(UnbekanntesSymptomEvaluation unbekanntesSymptom) { - this.unbekanntesSymptom = unbekanntesSymptom; - } - - public PartyProxy getComposer() { - return this.composer; - } - - public void setComposer(PartyProxy composer) { - this.composer = composer; - } - - public Language getLanguage() { - return this.language; - } - - public void setLanguage(Language language) { - this.language = language; - } - - public FeederAudit getFeederAudit() { - return this.feederAudit; - } - - public void setFeederAudit(FeederAudit feederAudit) { - this.feederAudit = feederAudit; - } - - public Territory getTerritory() { - return this.territory; - } - - public void setTerritory(Territory territory) { - this.territory = territory; - } - - public VersionUid getVersionUid() { - return this.versionUid; - } - - public void setVersionUid(VersionUid versionUid) { - this.versionUid = versionUid; - } + public void setAusgeschlossenesSymptom( + AusgeschlossenesSymptomEvaluation ausgeschlossenesSymptom) { + this.ausgeschlossenesSymptom = ausgeschlossenesSymptom; + } + + public AusgeschlossenesSymptomEvaluation getAusgeschlossenesSymptom() { + return this.ausgeschlossenesSymptom ; + } + + public void setUnbekanntesSymptom(UnbekanntesSymptomEvaluation unbekanntesSymptom) { + this.unbekanntesSymptom = unbekanntesSymptom; + } + + public UnbekanntesSymptomEvaluation getUnbekanntesSymptom() { + return this.unbekanntesSymptom ; + } + + public void setComposer(PartyProxy composer) { + this.composer = composer; + } + + public PartyProxy getComposer() { + return this.composer ; + } + + public void setLanguage(Language language) { + this.language = language; + } + + public Language getLanguage() { + return this.language ; + } + + public void setFeederAudit(FeederAudit feederAudit) { + this.feederAudit = feederAudit; + } + + public FeederAudit getFeederAudit() { + return this.feederAudit ; + } + + public void setTerritory(Territory territory) { + this.territory = territory; + } + + public Territory getTerritory() { + return this.territory ; + } + + public VersionUid getVersionUid() { + return this.versionUid ; + } + + public void setVersionUid(VersionUid versionUid) { + this.versionUid = versionUid; + } } diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/SymptomCompositionContainment.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/SymptomCompositionContainment.java index e79771ceb..2900e1cd8 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/SymptomCompositionContainment.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/SymptomCompositionContainment.java @@ -2,7 +2,6 @@ import com.nedap.archie.rm.archetyped.FeederAudit; import com.nedap.archie.rm.datastructures.Cluster; -import com.nedap.archie.rm.datavalues.DvCodedText; import com.nedap.archie.rm.generic.Participation; import com.nedap.archie.rm.generic.PartyIdentified; import com.nedap.archie.rm.generic.PartyProxy; @@ -19,6 +18,7 @@ import org.ehrbase.client.classgenerator.shareddefinition.Setting; import org.ehrbase.client.classgenerator.shareddefinition.Territory; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.AusgeschlossenesSymptomEvaluation; +import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.KategorieDefiningCode; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.StatusDefiningCode; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.UnbekanntesSymptomEvaluation; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.VorliegendesSymptomObservation; @@ -34,7 +34,7 @@ public class SymptomCompositionContainment extends Containment { public SelectAqlField STATUS_NULL_FLAVOUR_DEFINING_CODE = new AqlFieldImp(SymptomComposition.class, "/context/other_context[at0001]/items[at0004]/null_flavour|defining_code", "statusNullFlavourDefiningCode", NullFlavour.class, this); - public SelectAqlField KATEGORIE = new AqlFieldImp(SymptomComposition.class, "/context/other_context[at0001]/items[at0005]/value", "kategorie", DvCodedText.class, this); + public SelectAqlField KATEGORIE_DEFINING_CODE = new AqlFieldImp(SymptomComposition.class, "/context/other_context[at0001]/items[at0005]/value|defining_code", "kategorieDefiningCode", KategorieDefiningCode.class, this); public SelectAqlField KATEGORIE_NULL_FLAVOUR_DEFINING_CODE = new AqlFieldImp(SymptomComposition.class, "/context/other_context[at0001]/items[at0005]/null_flavour|defining_code", "kategorieNullFlavourDefiningCode", NullFlavour.class, this); diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AusgeschlossenesSymptomEvaluation.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AusgeschlossenesSymptomEvaluation.java index ef30d3a63..224766da6 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AusgeschlossenesSymptomEvaluation.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AusgeschlossenesSymptomEvaluation.java @@ -2,7 +2,6 @@ import com.nedap.archie.rm.archetyped.FeederAudit; import com.nedap.archie.rm.datastructures.Cluster; -import com.nedap.archie.rm.datavalues.DvCodedText; import com.nedap.archie.rm.generic.PartyProxy; import java.util.List; import javax.annotation.processing.Generated; @@ -17,17 +16,17 @@ @Archetype("openEHR-EHR-EVALUATION.exclusion_specific.v1") @Generated( value = "org.ehrbase.client.classgenerator.ClassGenerator", - date = "2021-03-09T14:41:23.671438+01:00", - comments = "https://github.com/ehrbase/openEHR_SDK Version: 1.3.0" + date = "2021-09-09T12:22:43.885951+02:00", + comments = "https://github.com/ehrbase/openEHR_SDK Version: 1.5.0" ) public class AusgeschlossenesSymptomEvaluation implements EntryEntity { /** * Path: COVID-19 Symptom/Ausgeschlossenes Symptom/Aussage über den Ausschluss * Description: Ein Bericht über den Ausschluss eines/r bestimmten Problems/Diagnose, familiäre Krankengeschichte, Medikation, Verfahren, Nebenwirkung oder eines anderen klinischen Ereignisses. - * Comment: Diese Beschreibung muss in Verbindung mit dem Datenelement "ausgeschlossene Kategorie" verwendet werden. Zum Beispiel: Dieses Datenelement kann zur Erfassung einer allgemeinen Aussage, wie z.B. "keine bekannte Vorgeschichte über..." verwendet werden. Die "ausgeschlossene Kategorie" spezifiziert die Aussage, in dem eine Zuordnung zu z.B. Diagnose oder Medikation vorgenommen werden kann. Wird bereits die "ausgeschlossene Kategorie" dafür genutzt, durch eine präkoordinierte Bezeichnung das Vorliegen von Diabetes in der familiären Krankengeschichte auszuschließen, ist der Eintrag in diesem Datenelement redundant. + * Comment: Diese Beschreibung muss in Verbindung mit dem Datenelement "ausgeschlossene Kategorie" verwendet werden. Zum Beispiel: Dieses Datenelement kann zur Erfassung einer allgemeinen Aussage, wie z.B. "keine bekannte Vorgeschichte über..." verwendet werden. Die "ausgeschlossene Kategorie" spezifiziert die Aussage, in dem eine Zuordnung zu z.B. Diagnose oder Medikation vorgenommen werden kann. Wird bereits die "ausgeschlossene Kategorie" dafür genutzt, durch eine präkoordinierte Bezeichnung das Vorliegen von Diabetes in der familiären Krankengeschichte auszuschließen, ist der Eintrag in diesem Datenelement redundant. */ - @Path("/data[at0001]/items[at0002]/value") - private DvCodedText aussageUeberDenAusschluss; + @Path("/data[at0001]/items[at0002]/value|defining_code") + private AussageUeberDenAusschlussDefiningCode aussageUeberDenAusschlussDefiningCode; /** * Path: COVID-19 Symptom/Ausgeschlossenes Symptom/Tree/Aussage über den Ausschluss/null_flavour @@ -48,8 +47,8 @@ public class AusgeschlossenesSymptomEvaluation implements EntryEntity { * * Wird das Datenelement wie in Beispiel (2) kodiert, ist eine weitere Spezifikation im Feld "Aussage über den Ausschluss" nicht notwendig. */ - @Path("/data[at0001]/items[at0003 and name/value='Problem/Diagnose']/value") - private DvCodedText problemDiagnose; + @Path("/data[at0001]/items[at0003 and name/value='Problem/Diagnose']/value|defining_code") + private NameDesSymptomsKrankheitsanzeichensDefiningCode problemDiagnoseDefiningCode; /** * Path: COVID-19 Symptom/Ausgeschlossenes Symptom/Tree/Problem/Diagnose/null_flavour @@ -83,12 +82,13 @@ public class AusgeschlossenesSymptomEvaluation implements EntryEntity { @Path("/feeder_audit") private FeederAudit feederAudit; - public void setAussageUeberDenAusschluss(DvCodedText aussageUeberDenAusschluss) { - this.aussageUeberDenAusschluss = aussageUeberDenAusschluss; + public void setAussageUeberDenAusschlussDefiningCode( + AussageUeberDenAusschlussDefiningCode aussageUeberDenAusschlussDefiningCode) { + this.aussageUeberDenAusschlussDefiningCode = aussageUeberDenAusschlussDefiningCode; } - public DvCodedText getAussageUeberDenAusschluss() { - return this.aussageUeberDenAusschluss ; + public AussageUeberDenAusschlussDefiningCode getAussageUeberDenAusschlussDefiningCode() { + return this.aussageUeberDenAusschlussDefiningCode ; } public void setAussageUeberDenAusschlussNullFlavourDefiningCode( @@ -100,12 +100,13 @@ public NullFlavour getAussageUeberDenAusschlussNullFlavourDefiningCode() { return this.aussageUeberDenAusschlussNullFlavourDefiningCode ; } - public void setProblemDiagnose(DvCodedText problemDiagnose) { - this.problemDiagnose = problemDiagnose; + public void setProblemDiagnoseDefiningCode( + NameDesSymptomsKrankheitsanzeichensDefiningCode problemDiagnoseDefiningCode) { + this.problemDiagnoseDefiningCode = problemDiagnoseDefiningCode; } - public DvCodedText getProblemDiagnose() { - return this.problemDiagnose ; + public NameDesSymptomsKrankheitsanzeichensDefiningCode getProblemDiagnoseDefiningCode() { + return this.problemDiagnoseDefiningCode ; } public void setProblemDiagnoseNullFlavourDefiningCode( diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AusgeschlossenesSymptomEvaluationContainment.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AusgeschlossenesSymptomEvaluationContainment.java index 85fbba41b..9665203f1 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AusgeschlossenesSymptomEvaluationContainment.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AusgeschlossenesSymptomEvaluationContainment.java @@ -2,7 +2,6 @@ import com.nedap.archie.rm.archetyped.FeederAudit; import com.nedap.archie.rm.datastructures.Cluster; -import com.nedap.archie.rm.datavalues.DvCodedText; import com.nedap.archie.rm.generic.PartyProxy; import org.ehrbase.client.aql.containment.Containment; import org.ehrbase.client.aql.field.AqlFieldImp; @@ -15,11 +14,11 @@ public class AusgeschlossenesSymptomEvaluationContainment extends Containment { public SelectAqlField AUSGESCHLOSSENES_SYMPTOM_EVALUATION = new AqlFieldImp(AusgeschlossenesSymptomEvaluation.class, "", "AusgeschlossenesSymptomEvaluation", AusgeschlossenesSymptomEvaluation.class, this); - public SelectAqlField AUSSAGE_UEBER_DEN_AUSSCHLUSS = new AqlFieldImp(AusgeschlossenesSymptomEvaluation.class, "/data[at0001]/items[at0002]/value", "aussageUeberDenAusschluss", DvCodedText.class, this); + public SelectAqlField AUSSAGE_UEBER_DEN_AUSSCHLUSS_DEFINING_CODE = new AqlFieldImp(AusgeschlossenesSymptomEvaluation.class, "/data[at0001]/items[at0002]/value|defining_code", "aussageUeberDenAusschlussDefiningCode", AussageUeberDenAusschlussDefiningCode.class, this); public SelectAqlField AUSSAGE_UEBER_DEN_AUSSCHLUSS_NULL_FLAVOUR_DEFINING_CODE = new AqlFieldImp(AusgeschlossenesSymptomEvaluation.class, "/data[at0001]/items[at0002]/null_flavour|defining_code", "aussageUeberDenAusschlussNullFlavourDefiningCode", NullFlavour.class, this); - public SelectAqlField PROBLEM_DIAGNOSE = new AqlFieldImp(AusgeschlossenesSymptomEvaluation.class, "/data[at0001]/items[at0003]/value", "problemDiagnose", DvCodedText.class, this); + public SelectAqlField PROBLEM_DIAGNOSE_DEFINING_CODE = new AqlFieldImp(AusgeschlossenesSymptomEvaluation.class, "/data[at0001]/items[at0003]/value|defining_code", "problemDiagnoseDefiningCode", NameDesSymptomsKrankheitsanzeichensDefiningCode.class, this); public SelectAqlField PROBLEM_DIAGNOSE_NULL_FLAVOUR_DEFINING_CODE = new AqlFieldImp(AusgeschlossenesSymptomEvaluation.class, "/data[at0001]/items[at0003]/null_flavour|defining_code", "problemDiagnoseNullFlavourDefiningCode", NullFlavour.class, this); diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AussageUberDenAusschlussDefiningCode.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AussageUberDenAusschlussDefiningCode.java deleted file mode 100644 index 520d5060c..000000000 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AussageUberDenAusschlussDefiningCode.java +++ /dev/null @@ -1,52 +0,0 @@ -package org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition; - -import com.nedap.archie.rm.datatypes.CodePhrase; -import com.nedap.archie.rm.datavalues.DvCodedText; -import com.nedap.archie.rm.support.identification.TerminologyId; -import org.ehrbase.client.classgenerator.EnumValueSet; - -public enum AussageUberDenAusschlussDefiningCode implements EnumValueSet { - N410594000("410594000", "410594000", "SNOMED Clinical Terms", "410594000"); - - private String value; - - private String description; - - private String terminologyId; - - private String code; - - AussageUberDenAusschlussDefiningCode(String value, String description, String terminologyId, - String code) { - this.value = value; - this.description = description; - this.terminologyId = terminologyId; - this.code = code; - } - - public String getValue() { - return this.value ; - } - - public String getDescription() { - return this.description ; - } - - public String getTerminologyId() { - return this.terminologyId ; - } - - public String getCode() { - return this.code ; - } - - public DvCodedText toDvCodedText(){ - DvCodedText dvCodedText = new DvCodedText(); - CodePhrase codePhrase = new CodePhrase(); - codePhrase.setCodeString(code); - codePhrase.setTerminologyId(new TerminologyId(terminologyId)); - dvCodedText.setDefiningCode(codePhrase); - dvCodedText.setValue(value); - return dvCodedText; - } -} diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AussageUeberDenAusschlussDefiningCode.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AussageUeberDenAusschlussDefiningCode.java new file mode 100644 index 000000000..44a21cf4f --- /dev/null +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AussageUeberDenAusschlussDefiningCode.java @@ -0,0 +1,40 @@ +package org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition; + +import java.lang.String; +import org.ehrbase.client.classgenerator.EnumValueSet; + +public enum AussageUeberDenAusschlussDefiningCode implements EnumValueSet { + KNOWN_ABSENT_QUALIFIER_VALUE("Known absent (qualifier value)", "", "SNOMED Clinical Terms", "410594000"); + + private String value; + + private String description; + + private String terminologyId; + + private String code; + + AussageUeberDenAusschlussDefiningCode(String value, String description, String terminologyId, + String code) { + this.value = value; + this.description = description; + this.terminologyId = terminologyId; + this.code = code; + } + + public String getValue() { + return this.value ; + } + + public String getDescription() { + return this.description ; + } + + public String getTerminologyId() { + return this.terminologyId ; + } + + public String getCode() { + return this.code ; + } +} diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AussageUeberDieFehlendeInformationDefiningCode.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AussageUeberDieFehlendeInformationDefiningCode.java new file mode 100644 index 000000000..2861b3ba4 --- /dev/null +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/AussageUeberDieFehlendeInformationDefiningCode.java @@ -0,0 +1,40 @@ +package org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition; + +import java.lang.String; +import org.ehrbase.client.classgenerator.EnumValueSet; + +public enum AussageUeberDieFehlendeInformationDefiningCode implements EnumValueSet { + UNKNOWN_QUALIFIER_VALUE("Unknown (qualifier value)", "", "SNOMED Clinical Terms", "261665006"); + + private String value; + + private String description; + + private String terminologyId; + + private String code; + + AussageUeberDieFehlendeInformationDefiningCode(String value, String description, + String terminologyId, String code) { + this.value = value; + this.description = description; + this.terminologyId = terminologyId; + this.code = code; + } + + public String getValue() { + return this.value ; + } + + public String getDescription() { + return this.description ; + } + + public String getTerminologyId() { + return this.terminologyId ; + } + + public String getCode() { + return this.code ; + } +} diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/DefiningCode.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/DefiningCode.java deleted file mode 100644 index f1717e767..000000000 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/DefiningCode.java +++ /dev/null @@ -1,51 +0,0 @@ -package org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition; - -import com.nedap.archie.rm.datatypes.CodePhrase; -import com.nedap.archie.rm.datavalues.DvCodedText; -import com.nedap.archie.rm.support.identification.TerminologyId; -import org.ehrbase.client.classgenerator.EnumValueSet; - -public enum DefiningCode implements EnumValueSet { - N261665006("261665006", "261665006", "SNOMED Clinical Terms", "261665006"); - - private String value; - - private String description; - - private String terminologyId; - - private String code; - - DefiningCode(String value, String description, String terminologyId, String code) { - this.value = value; - this.description = description; - this.terminologyId = terminologyId; - this.code = code; - } - - public String getValue() { - return this.value ; - } - - public String getDescription() { - return this.description ; - } - - public String getTerminologyId() { - return this.terminologyId ; - } - - public String getCode() { - return this.code ; - } - - public DvCodedText toDvCodedText(){ - DvCodedText dvCodedText = new DvCodedText(); - CodePhrase codePhrase = new CodePhrase(); - codePhrase.setCodeString(code); - codePhrase.setTerminologyId(new TerminologyId(terminologyId)); - dvCodedText.setDefiningCode(codePhrase); - dvCodedText.setValue(value); - return dvCodedText; - } -} diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/KategorieDefiningCode.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/KategorieDefiningCode.java new file mode 100644 index 000000000..a773b24cf --- /dev/null +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/KategorieDefiningCode.java @@ -0,0 +1,39 @@ +package org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition; + +import java.lang.String; +import org.ehrbase.client.classgenerator.EnumValueSet; + +public enum KategorieDefiningCode implements EnumValueSet { + SYMPTOM("Symptom", "", "LOINC", "75325-1"); + + private String value; + + private String description; + + private String terminologyId; + + private String code; + + KategorieDefiningCode(String value, String description, String terminologyId, String code) { + this.value = value; + this.description = description; + this.terminologyId = terminologyId; + this.code = code; + } + + public String getValue() { + return this.value ; + } + + public String getDescription() { + return this.description ; + } + + public String getTerminologyId() { + return this.terminologyId ; + } + + public String getCode() { + return this.code ; + } +} diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/KategorieDefiningCodeSymptom.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/KategorieDefiningCodeSymptom.java deleted file mode 100644 index d2950a9e3..000000000 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/KategorieDefiningCodeSymptom.java +++ /dev/null @@ -1,51 +0,0 @@ -package org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition; - -import com.nedap.archie.rm.datatypes.CodePhrase; -import com.nedap.archie.rm.datavalues.DvCodedText; -import com.nedap.archie.rm.support.identification.TerminologyId; -import org.ehrbase.client.classgenerator.EnumValueSet; - -public enum KategorieDefiningCodeSymptom implements EnumValueSet { - N753251("75325-1", "75325-1", "LOINC", "75325-1"); - - private String value; - - private String description; - - private String terminologyId; - - private String code; - - KategorieDefiningCodeSymptom(String value, String description, String terminologyId, String code) { - this.value = value; - this.description = description; - this.terminologyId = terminologyId; - this.code = code; - } - - public String getValue() { - return this.value ; - } - - public String getDescription() { - return this.description ; - } - - public String getTerminologyId() { - return this.terminologyId ; - } - - public String getCode() { - return this.code ; - } - - public DvCodedText toDvCodedText(){ - DvCodedText dvCodedText = new DvCodedText(); - CodePhrase codePhrase = new CodePhrase(); - codePhrase.setCodeString(code); - codePhrase.setTerminologyId(new TerminologyId(terminologyId)); - dvCodedText.setDefiningCode(codePhrase); - dvCodedText.setValue(value); - return dvCodedText; - } -} diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/KrankheitsanzeichenCode.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/KrankheitsanzeichenCode.java deleted file mode 100644 index 9f1726319..000000000 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/KrankheitsanzeichenCode.java +++ /dev/null @@ -1,140 +0,0 @@ -package org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition; - -import com.nedap.archie.rm.datatypes.CodePhrase; -import com.nedap.archie.rm.datavalues.DvCodedText; -import com.nedap.archie.rm.support.identification.TerminologyId; -import org.ehrbase.client.classgenerator.EnumValueSet; - -import java.util.HashMap; -import java.util.Map; - -public enum KrankheitsanzeichenCode implements EnumValueSet { - N49727002("49727002", "49727002", "SNOMED Clinical Terms", "49727002"), - - N44169009("44169009", "44169009", "SNOMED Clinical Terms", "44169009"), - - N56018004("56018004", "56018004", "SNOMED Clinical Terms", "56018004"), - - N271807003("271807003", "271807003", "SNOMED Clinical Terms", "271807003"), - - N103001002("103001002", "103001002", "SNOMED Clinical Terms", "103001002"), - - N162397003("162397003", "162397003", "SNOMED Clinical Terms", "162397003"), - - N386661006("386661006", "386661006", "SNOMED Clinical Terms", "386661006"), - - N29857009("29857009", "29857009", "SNOMED Clinical Terms", "29857009"), - - N9826008("9826008", "9826008", "SNOMED Clinical Terms", "9826008"), - - N28743005("28743005", "28743005", "SNOMED Clinical Terms", "28743005"), - - N267036007("267036007", "267036007", "SNOMED Clinical Terms", "267036007"), - - N66857006("66857006", "66857006", "SNOMED Clinical Terms", "66857006"), - - N13791008("13791008", "13791008", "SNOMED Clinical Terms", "13791008"), - - N62315008("62315008", "62315008", "SNOMED Clinical Terms", "62315008"), - - N3006004("3006004", "3006004", "SNOMED Clinical Terms", "3006004"), - - N84387000("84387000", "84387000", "SNOMED Clinical Terms", "84387000"), - - N11833005("11833005", "11833005", "SNOMED Clinical Terms", "11833005"), - - N43724002("43724002", "43724002", "SNOMED Clinical Terms", "43724002"), - - N25064002("25064002", "25064002", "SNOMED Clinical Terms", "25064002"), - - N68962001("68962001", "68962001", "SNOMED Clinical Terms", "68962001"), - - N79890006("79890006", "79890006", "SNOMED Clinical Terms", "79890006"), - - N84229001("84229001", "84229001", "SNOMED Clinical Terms", "84229001"), - - N46742003("46742003", "46742003", "SNOMED Clinical Terms", "46742003"), - - N422400008("422400008", "422400008", "SNOMED Clinical Terms", "422400008"), - - N64531003("64531003", "64531003", "SNOMED Clinical Terms", "64531003"), - - N30746006("30746006", "30746006", "SNOMED Clinical Terms", "30746006"), - - N248567008("248567008", "248567008", "SNOMED Clinical Terms", "248567008"), - - N21522001("21522001", "21522001", "SNOMED Clinical Terms", "21522001"), - - N367391008("367391008", "367391008", "SNOMED Clinical Terms", "367391008"), - - N40917007("40917007", "40917007", "SNOMED Clinical Terms", "40917007"), - - N131148009("131148009", "131148009", "SNOMED Clinical Terms", "131148009"), - - N22253000("22253000", "22253000", "SNOMED Clinical Terms", "22253000"), - - N282145008("282145008", "282145008", "SNOMED Clinical Terms", "282145008"), - - N36955009("36955009", "36955009", "SNOMED Clinical Terms", "36955009"), - - N422587007("422587007", "422587007", "SNOMED Clinical Terms", "422587007"), - - N426000000("426000000", "426000000", "SNOMED Clinical Terms", "426000000"), - - N38880002("38880002", "38880002", "SNOMED Clinical Terms", "38880002"), - - N91175000("91175000", "91175000", "SNOMED Clinical Terms", "91175000"), - - N57676002("57676002", "57676002", "SNOMED Clinical Terms", "57676002"), - - N68235000("68235000", "68235000", "SNOMED Clinical Terms", "68235000"); - - private String value; - - private String description; - - private String terminologyId; - - private String code; - - KrankheitsanzeichenCode(String value, String description, String terminologyId, String code) { - this.value = value; - this.description = description; - this.terminologyId = terminologyId; - this.code = code; - } - - public String getValue() { - return this.value ; - } - - public String getDescription() { - return this.description ; - } - - public String getTerminologyId() { - return this.terminologyId ; - } - - public String getCode() { - return this.code ; - } - - public static Map getCodesAsMap(){ - Map krankheitszeichenMap = new HashMap<>(); - for (KrankheitsanzeichenCode krankheitszeichen : KrankheitsanzeichenCode.values()) { - krankheitszeichenMap.put(krankheitszeichen.getCode(), krankheitszeichen); - } - return krankheitszeichenMap; - } - - public DvCodedText toDvCodedText(){ - DvCodedText dvCodedText = new DvCodedText(); - CodePhrase codePhrase = new CodePhrase(); - codePhrase.setCodeString(code); - codePhrase.setTerminologyId(new TerminologyId(terminologyId)); - dvCodedText.setDefiningCode(codePhrase); - dvCodedText.setValue(value); - return dvCodedText; - } -} diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/NameDesSymptomsKrankheitsanzeichensDefiningCode.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/NameDesSymptomsKrankheitsanzeichensDefiningCode.java new file mode 100644 index 000000000..fae847723 --- /dev/null +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/NameDesSymptomsKrankheitsanzeichensDefiningCode.java @@ -0,0 +1,129 @@ +package org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition; + +import java.lang.String; +import java.util.HashMap; +import java.util.Map; + +import org.ehrbase.client.classgenerator.EnumValueSet; + +public enum NameDesSymptomsKrankheitsanzeichensDefiningCode implements EnumValueSet { + DIARRHEA_FINDING("Diarrhea (finding)", "", "SNOMED Clinical Terms", "62315008"), + + ASTHENIA_FINDING("Asthenia (finding)", "", "SNOMED Clinical Terms", "13791008"), + + CLOUDED_CONSCIOUSNESS_FINDING("Clouded consciousness (finding)", "", "SNOMED Clinical Terms", "40917007"), + + ASYMPTOMATIC_FINDING("Asymptomatic (finding)", "", "SNOMED Clinical Terms", "84387000"), + + DRY_COUGH_FINDING("Dry cough (finding)", "", "SNOMED Clinical Terms", "11833005"), + + CHEST_PAIN_FINDING("Chest pain (finding)", "", "SNOMED Clinical Terms", "29857009"), + + MUSCLE_PAIN_FINDING("Muscle pain (finding)", "", "SNOMED Clinical Terms", "68962001"), + + SEIZURE_FINDING("Seizure (finding)", "", "SNOMED Clinical Terms", "91175000"), + + VOMITING_DISORDER("Vomiting (disorder)", "", "SNOMED Clinical Terms", "422400008"), + + PAIN_FINDING("Pain (finding)", "", "SNOMED Clinical Terms", "22253000"), + + PRODUCTIVE_COUGH_FINDING("Productive cough (finding)", "", "SNOMED Clinical Terms", "28743005"), + + NAUSEA_FINDING("Nausea (finding)", "", "SNOMED Clinical Terms", "422587007"), + + DISTURBANCE_OF_CONSCIOUSNESS_FINDING("Disturbance of consciousness (finding)", "", "SNOMED Clinical Terms", "3006004"), + + LOSS_OF_SENSE_OF_SMELL_FINDING("Loss of sense of smell (finding)", "", "SNOMED Clinical Terms", "44169009"), + + PAIN_IN_THROAT_FINDING("Pain in throat (finding)", "", "SNOMED Clinical Terms", "162397003"), + + ERUPTION_OF_SKIN_DISORDER("Eruption of skin (disorder)", "", "SNOMED Clinical Terms", "271807003"), + + HEADACHE_FINDING("Headache (finding)", "", "SNOMED Clinical Terms", "25064002"), + + JOINT_PAIN_FINDING("Joint pain (finding)", "", "SNOMED Clinical Terms", "57676002"), + + FATIGUE_FINDING("Fatigue (finding)", "", "SNOMED Clinical Terms", "84229001"), + + WHEEZING_FINDING("Wheezing (finding)", "", "SNOMED Clinical Terms", "56018004"), + + LOSS_OF_TASTE_FINDING("Loss of taste (finding)", "", "SNOMED Clinical Terms", "36955009"), + + BLEEDING_FINDING("Bleeding (finding)", "", "SNOMED Clinical Terms", "131148009"), + + INDRAWING_OF_RIBS_DURING_RESPIRATION_FINDING("Indrawing of ribs during respiration (finding)", "", "SNOMED Clinical Terms", "248567008"), + + UNABLE_TO_WALK_FINDING("Unable to walk (finding)", "", "SNOMED Clinical Terms", "282145008"), + + NASAL_DISCHARGE_FINDING("Nasal discharge (finding)", "", "SNOMED Clinical Terms", "64531003"), + + SKIN_ULCER_DISORDER("Skin ulcer (disorder)", "", "SNOMED Clinical Terms", "46742003"), + + ABDOMINAL_PAIN_FINDING("Abdominal pain (finding)", "", "SNOMED Clinical Terms", "21522001"), + + COUGH_FINDING("Cough (finding)", "", "SNOMED Clinical Terms", "49727002"), + + MALAISE_FINDING("Malaise (finding)", "", "SNOMED Clinical Terms", "367391008"), + + HEMOPTYSIS_FINDING("Hemoptysis (finding)", "", "SNOMED Clinical Terms", "66857006"), + + FEVER_GREATER_THAN1004_FAHRENHEIT38_CELSIUS_FINDING("Fever greater than 100.4 Fahrenheit / 38° Celsius (finding)", "", "SNOMED Clinical Terms", "426000000"), + + CHILL_FINDING("Chill (finding)", "", "SNOMED Clinical Terms", "43724002"), + + RIGOR_FINDING("Rigor (finding)", "", "SNOMED Clinical Terms", "38880002"), + + LYMPHADENOPATHY_DISORDER("Lymphadenopathy (disorder)", "", "SNOMED Clinical Terms", "30746006"), + + FEVER_FINDING("Fever (finding)", "", "SNOMED Clinical Terms", "386661006"), + + FEELING_FEVERISH_FINDING("Feeling feverish (finding)", "", "SNOMED Clinical Terms", "103001002"), + + NASAL_CONGESTION_FINDING("Nasal congestion (finding)", "", "SNOMED Clinical Terms", "68235000"), + + LOSS_OF_APPETITE_FINDING("Loss of appetite (finding)", "", "SNOMED Clinical Terms", "79890006"), + + CONJUNCTIVITIS_DISORDER("Conjunctivitis (disorder)", "", "SNOMED Clinical Terms", "9826008"), + + DYSPNEA_FINDING("Dyspnea (finding)", "", "SNOMED Clinical Terms", "267036007"); + + private String value; + + private String description; + + private String terminologyId; + + private String code; + + NameDesSymptomsKrankheitsanzeichensDefiningCode(String value, String description, + String terminologyId, String code) { + this.value = value; + this.description = description; + this.terminologyId = terminologyId; + this.code = code; + } + + public static Map getCodesAsMap(){ + Map nameDesSymptomsKrankheitsanzeichensDefiningCodeMap = new HashMap<>(); + for (NameDesSymptomsKrankheitsanzeichensDefiningCode nameDesSymptomsKrankheitsanzeichensDefiningCode : NameDesSymptomsKrankheitsanzeichensDefiningCode.values()) { + nameDesSymptomsKrankheitsanzeichensDefiningCodeMap.put(nameDesSymptomsKrankheitsanzeichensDefiningCode.getCode(), nameDesSymptomsKrankheitsanzeichensDefiningCode); + } + return nameDesSymptomsKrankheitsanzeichensDefiningCodeMap; + } + + public String getValue() { + return this.value ; + } + + public String getDescription() { + return this.description ; + } + + public String getTerminologyId() { + return this.terminologyId ; + } + + public String getCode() { + return this.code ; + } +} diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/SchweregradDefiningCode.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/SchweregradDefiningCode.java new file mode 100644 index 000000000..8091af225 --- /dev/null +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/SchweregradDefiningCode.java @@ -0,0 +1,56 @@ +package org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition; + +import java.lang.String; +import java.util.HashMap; +import java.util.Map; + +import org.ehrbase.client.classgenerator.EnumValueSet; + +public enum SchweregradDefiningCode implements EnumValueSet { + SEVERE_SEVERITY_MODIFIER_QUALIFIER_VALUE("Severe (severity modifier) (qualifier value)", "", "SNOMED Clinical Terms", "24484000"), + + LIFE_THREATENING_SEVERITY_QUALIFIER_VALUE("Life threatening severity (qualifier value)", "", "SNOMED Clinical Terms", "442452003"), + + MILD_QUALIFIER_VALUE("Mild (qualifier value)", "", "SNOMED Clinical Terms", "255604002"), + + MODERATE_SEVERITY_MODIFIER_QUALIFIER_VALUE("Moderate (severity modifier) (qualifier value)", "", "SNOMED Clinical Terms", "6736007"); + + private String value; + + private String description; + + private String terminologyId; + + private String code; + + SchweregradDefiningCode(String value, String description, String terminologyId, String code) { + this.value = value; + this.description = description; + this.terminologyId = terminologyId; + this.code = code; + } + + public static Map getCodesAsMap(){ + Map stringSchweregradSymptomCodeHashMap = new HashMap<>(); + for (SchweregradDefiningCode schweregradSymptomCode : SchweregradDefiningCode.values()) { + stringSchweregradSymptomCodeHashMap.put(schweregradSymptomCode.getCode(), schweregradSymptomCode); + } + return stringSchweregradSymptomCodeHashMap; + } + + public String getValue() { + return this.value ; + } + + public String getDescription() { + return this.description ; + } + + public String getTerminologyId() { + return this.terminologyId ; + } + + public String getCode() { + return this.code ; + } +} diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/SchweregradSymptomCode.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/SchweregradSymptomCode.java deleted file mode 100644 index cbf839b3a..000000000 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/SchweregradSymptomCode.java +++ /dev/null @@ -1,68 +0,0 @@ -package org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition; - -import com.nedap.archie.rm.datatypes.CodePhrase; -import com.nedap.archie.rm.datavalues.DvCodedText; -import com.nedap.archie.rm.support.identification.TerminologyId; -import org.ehrbase.client.classgenerator.EnumValueSet; - -import java.util.HashMap; -import java.util.Map; - -public enum SchweregradSymptomCode implements EnumValueSet { - N442452003("442452003", "442452003", "SNOMED Clinical Terms", "442452003"), - - N24484000("24484000", "24484000", "SNOMED Clinical Terms", "24484000"), - - N255604002("255604002", "255604002", "SNOMED Clinical Terms", "255604002"), - - N6736007("6736007", "6736007", "SNOMED Clinical Terms", "6736007"); - - private String value; - - private String description; - - private String terminologyId; - - private String code; - - SchweregradSymptomCode(String value, String description, String terminologyId, String code) { - this.value = value; - this.description = description; - this.terminologyId = terminologyId; - this.code = code; - } - - public static Map getCodesAsMap(){ - Map stringSchweregradSymptomCodeHashMap = new HashMap<>(); - for (SchweregradSymptomCode schweregradSymptomCode : SchweregradSymptomCode.values()) { - stringSchweregradSymptomCodeHashMap.put(schweregradSymptomCode.getCode(), schweregradSymptomCode); - } - return stringSchweregradSymptomCodeHashMap; - } - - public String getValue() { - return this.value ; - } - - public String getDescription() { - return this.description ; - } - - public String getTerminologyId() { - return this.terminologyId ; - } - - public String getCode() { - return this.code ; - } - - public DvCodedText toDvCodedText(){ - DvCodedText dvCodedText = new DvCodedText(); - CodePhrase codePhrase = new CodePhrase(); - codePhrase.setCodeString(code); - codePhrase.setTerminologyId(new TerminologyId(terminologyId)); - dvCodedText.setDefiningCode(codePhrase); - dvCodedText.setValue(value); - return dvCodedText; - } -} diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/UnbekanntesSymptomAussageUeberDieFehlendeInformationElement.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/UnbekanntesSymptomAussageUeberDieFehlendeInformationElement.java index 738aaac4d..3d2137f51 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/UnbekanntesSymptomAussageUeberDieFehlendeInformationElement.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/UnbekanntesSymptomAussageUeberDieFehlendeInformationElement.java @@ -1,7 +1,6 @@ package org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition; import com.nedap.archie.rm.archetyped.FeederAudit; -import com.nedap.archie.rm.datavalues.DvCodedText; import javax.annotation.processing.Generated; import org.ehrbase.client.annotations.Entity; import org.ehrbase.client.annotations.Path; @@ -11,8 +10,8 @@ @Entity @Generated( value = "org.ehrbase.client.classgenerator.ClassGenerator", - date = "2021-03-09T14:41:23.681437+01:00", - comments = "https://github.com/ehrbase/openEHR_SDK Version: 1.3.0" + date = "2021-09-09T12:22:43.897827+02:00", + comments = "https://github.com/ehrbase/openEHR_SDK Version: 1.5.0" ) public class UnbekanntesSymptomAussageUeberDieFehlendeInformationElement implements LocatableEntity { /** @@ -20,8 +19,8 @@ public class UnbekanntesSymptomAussageUeberDieFehlendeInformationElement impleme * Description: Beschreibung des Grundes, warum keine Informationen vorhanden sind. * Comment: Zum Beispiel: Der Patient ist bewusstlos oder weigert sich Informationen preiszugeben. Die Codierung mit einer Terminologie wird empfohlen, wenn möglich. */ - @Path("/value") - private DvCodedText value; + @Path("/value|defining_code") + private AussageUeberDieFehlendeInformationDefiningCode value; /** * Path: COVID-19 Symptom/Unbekanntes Symptom/Baum/Aussage über die fehlende Information/null_flavour @@ -35,11 +34,11 @@ public class UnbekanntesSymptomAussageUeberDieFehlendeInformationElement impleme @Path("/feeder_audit") private FeederAudit feederAudit; - public void setValue(DvCodedText value) { + public void setValue(AussageUeberDieFehlendeInformationDefiningCode value) { this.value = value; } - public DvCodedText getValue() { + public AussageUeberDieFehlendeInformationDefiningCode getValue() { return this.value ; } diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/UnbekanntesSymptomEvaluation.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/UnbekanntesSymptomEvaluation.java index 810d84361..0e36435e9 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/UnbekanntesSymptomEvaluation.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/UnbekanntesSymptomEvaluation.java @@ -2,7 +2,6 @@ import com.nedap.archie.rm.archetyped.FeederAudit; import com.nedap.archie.rm.datastructures.Cluster; -import com.nedap.archie.rm.datavalues.DvCodedText; import com.nedap.archie.rm.generic.PartyProxy; import java.util.List; import javax.annotation.processing.Generated; @@ -17,8 +16,8 @@ @Archetype("openEHR-EHR-EVALUATION.absence.v2") @Generated( value = "org.ehrbase.client.classgenerator.ClassGenerator", - date = "2021-03-09T14:41:23.678638+01:00", - comments = "https://github.com/ehrbase/openEHR_SDK Version: 1.3.0" + date = "2021-09-09T12:22:43.893672+02:00", + comments = "https://github.com/ehrbase/openEHR_SDK Version: 1.5.0" ) public class UnbekanntesSymptomEvaluation implements EntryEntity { /** @@ -26,8 +25,8 @@ public class UnbekanntesSymptomEvaluation implements EntryEntity { * Description: Positive Aussage, dass keine Informationen verfügbar sind. * Comment: Zum Beispiel: "Es liegen keine Informationen über Nebenwirkungen vor"; "Es liegen keine Informationen über Probleme oder Diagnosen vor"; "Es liegen keine Informationen über vorangegangene Verfahren vor"; oder "Es liegen keine Informationen über verwendete Medikamente vor". */ - @Path("/data[at0001]/items[at0002 and name/value='Unbekanntes Symptom']/value") - private DvCodedText unbekanntesSymptom; + @Path("/data[at0001]/items[at0002 and name/value='Unbekanntes Symptom']/value|defining_code") + private NameDesSymptomsKrankheitsanzeichensDefiningCode unbekanntesSymptomDefiningCode; /** * Path: COVID-19 Symptom/Unbekanntes Symptom/Baum/Unbekanntes Symptom/null_flavour @@ -69,12 +68,13 @@ public class UnbekanntesSymptomEvaluation implements EntryEntity { @Path("/feeder_audit") private FeederAudit feederAudit; - public void setUnbekanntesSymptom(DvCodedText unbekanntesSymptom) { - this.unbekanntesSymptom = unbekanntesSymptom; + public void setUnbekanntesSymptomDefiningCode( + NameDesSymptomsKrankheitsanzeichensDefiningCode unbekanntesSymptomDefiningCode) { + this.unbekanntesSymptomDefiningCode = unbekanntesSymptomDefiningCode; } - public DvCodedText getUnbekanntesSymptom() { - return this.unbekanntesSymptom ; + public NameDesSymptomsKrankheitsanzeichensDefiningCode getUnbekanntesSymptomDefiningCode() { + return this.unbekanntesSymptomDefiningCode ; } public void setUnbekanntesSymptomNullFlavourDefiningCode( diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/UnbekanntesSymptomEvaluationContainment.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/UnbekanntesSymptomEvaluationContainment.java index 44a10b450..4e2eb04f9 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/UnbekanntesSymptomEvaluationContainment.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/UnbekanntesSymptomEvaluationContainment.java @@ -2,7 +2,6 @@ import com.nedap.archie.rm.archetyped.FeederAudit; import com.nedap.archie.rm.datastructures.Cluster; -import com.nedap.archie.rm.datavalues.DvCodedText; import com.nedap.archie.rm.generic.PartyProxy; import org.ehrbase.client.aql.containment.Containment; import org.ehrbase.client.aql.field.AqlFieldImp; @@ -15,7 +14,7 @@ public class UnbekanntesSymptomEvaluationContainment extends Containment { public SelectAqlField UNBEKANNTES_SYMPTOM_EVALUATION = new AqlFieldImp(UnbekanntesSymptomEvaluation.class, "", "UnbekanntesSymptomEvaluation", UnbekanntesSymptomEvaluation.class, this); - public SelectAqlField UNBEKANNTES_SYMPTOM = new AqlFieldImp(UnbekanntesSymptomEvaluation.class, "/data[at0001]/items[at0002]/value", "unbekanntesSymptom", DvCodedText.class, this); + public SelectAqlField UNBEKANNTES_SYMPTOM_DEFINING_CODE = new AqlFieldImp(UnbekanntesSymptomEvaluation.class, "/data[at0001]/items[at0002]/value|defining_code", "unbekanntesSymptomDefiningCode", NameDesSymptomsKrankheitsanzeichensDefiningCode.class, this); public SelectAqlField UNBEKANNTES_SYMPTOM_NULL_FLAVOUR_DEFINING_CODE = new AqlFieldImp(UnbekanntesSymptomEvaluation.class, "/data[at0001]/items[at0002]/null_flavour|defining_code", "unbekanntesSymptomNullFlavourDefiningCode", NullFlavour.class, this); diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/VorliegendesSymptomAnatomischeLokalisationElement.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/VorliegendesSymptomAnatomischeLokalisationElement.java index d04876a3f..cb269a127 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/VorliegendesSymptomAnatomischeLokalisationElement.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/VorliegendesSymptomAnatomischeLokalisationElement.java @@ -11,8 +11,8 @@ @Entity @Generated( value = "org.ehrbase.client.classgenerator.ClassGenerator", - date = "2021-03-09T14:41:23.651477+01:00", - comments = "https://github.com/ehrbase/openEHR_SDK Version: 1.3.0" + date = "2021-09-09T12:22:43.869516+02:00", + comments = "https://github.com/ehrbase/openEHR_SDK Version: 1.5.0" ) public class VorliegendesSymptomAnatomischeLokalisationElement implements LocatableEntity { /** diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/VorliegendesSymptomObservation.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/VorliegendesSymptomObservation.java index b4e69c54c..c41568261 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/VorliegendesSymptomObservation.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/VorliegendesSymptomObservation.java @@ -2,7 +2,6 @@ import com.nedap.archie.rm.archetyped.FeederAudit; import com.nedap.archie.rm.datastructures.Cluster; -import com.nedap.archie.rm.datavalues.DvCodedText; import com.nedap.archie.rm.generic.PartyProxy; import java.time.temporal.TemporalAccessor; import java.util.List; @@ -18,8 +17,8 @@ @Archetype("openEHR-EHR-OBSERVATION.symptom_sign.v0") @Generated( value = "org.ehrbase.client.classgenerator.ClassGenerator", - date = "2021-03-09T14:41:23.646936+01:00", - comments = "https://github.com/ehrbase/openEHR_SDK Version: 1.3.0" + date = "2021-09-09T12:22:43.860639+02:00", + comments = "https://github.com/ehrbase/openEHR_SDK Version: 1.5.0" ) public class VorliegendesSymptomObservation implements EntryEntity { /** @@ -27,8 +26,8 @@ public class VorliegendesSymptomObservation implements EntryEntity { * Description: Der Name des berichteten Symptoms/Krankheitsanzeichens. * Comment: Der Name des Symptoms sollte, wenn möglich, mit einer Terminologie kodiert werden. */ - @Path("/data[at0190]/events[at0191]/data[at0192]/items[at0001]/value") - private DvCodedText nameDesSymptomsKrankheitsanzeichens; + @Path("/data[at0190]/events[at0191]/data[at0192]/items[at0001]/value|defining_code") + private NameDesSymptomsKrankheitsanzeichensDefiningCode nameDesSymptomsKrankheitsanzeichensDefiningCode; /** * Path: COVID-19 Symptom/Vorliegendes Symptom/Event Series/*Any event(en)/Tree/Name des Symptoms/Krankheitsanzeichens/null_flavour @@ -72,8 +71,8 @@ public class VorliegendesSymptomObservation implements EntryEntity { * Description: Kategorie, die den allgemeinen Schweregrad des Symptoms/Krankheitsanzeichens beschreibt. * Comment: Werte wie leicht, moderat oder schwer so zu definieren, dass sie auf mehrere Symptome/Befunde anwendbar sind und von verschiedenen Benutzern interpretiert und einheitlich dokumentiert werden können, ist nicht einfach. Einige Organisationen erweitern die Wertemenge, indem sie zusätzliche Werte, wie z.B. "trivial", "sehr stark", "leicht-moderat" oder "moderat-schwer", miteinbeziehen, was zu Definitionsschwierigkeiten führt und auch die Zuverlässigkeit von Aufzeichnungen von verschiedenen Protokollanten verschlechtern kann. Die Verwendung von "lebensbedrohlich" und "tödlich" wird ebenfalls oft als Teil dieser Wertemenge betrachtet, obwohl sie eher ein Ergebnis als einen Schweregrad widerspiegelt. In Anbetracht dessen wird die Einhaltung einer gut definierten, aber kürzeren Liste bevorzugt, so dass der leichte/mittlere/schwere Wertebereich angeboten wird. Die Wahl eines anderen Textes wird durch die Aufnahme anderer Wertebereiche für dieses Datenelement im Template ermöglicht. Hinweis: Eine spezifischere Einstufung des Schweregrads kann mit Hilfe der Slots "Spezifische Details" vorgenommen werden. */ - @Path("/data[at0190]/events[at0191]/data[at0192]/items[at0021]/value") - private DvCodedText schweregrad; + @Path("/data[at0190]/events[at0191]/data[at0192]/items[at0021]/value|defining_code") + private SchweregradDefiningCode schweregradDefiningCode; /** * Path: COVID-19 Symptom/Vorliegendes Symptom/Event Series/*Any event(en)/Tree/Schweregrad/null_flavour @@ -157,13 +156,14 @@ public class VorliegendesSymptomObservation implements EntryEntity { @Path("/feeder_audit") private FeederAudit feederAudit; - public void setNameDesSymptomsKrankheitsanzeichens( - DvCodedText nameDesSymptomsKrankheitsanzeichens) { - this.nameDesSymptomsKrankheitsanzeichens = nameDesSymptomsKrankheitsanzeichens; + public void setNameDesSymptomsKrankheitsanzeichensDefiningCode( + NameDesSymptomsKrankheitsanzeichensDefiningCode nameDesSymptomsKrankheitsanzeichensDefiningCode) { + this.nameDesSymptomsKrankheitsanzeichensDefiningCode = nameDesSymptomsKrankheitsanzeichensDefiningCode; } - public DvCodedText getNameDesSymptomsKrankheitsanzeichens() { - return this.nameDesSymptomsKrankheitsanzeichens ; + public NameDesSymptomsKrankheitsanzeichensDefiningCode getNameDesSymptomsKrankheitsanzeichensDefiningCode( + ) { + return this.nameDesSymptomsKrankheitsanzeichensDefiningCode ; } public void setNameDesSymptomsKrankheitsanzeichensNullFlavourDefiningCode( @@ -210,12 +210,12 @@ public NullFlavour getBeginnDerEpisodeNullFlavourDefiningCode() { return this.beginnDerEpisodeNullFlavourDefiningCode ; } - public void setSchweregrad(DvCodedText schweregrad) { - this.schweregrad = schweregrad; + public void setSchweregradDefiningCode(SchweregradDefiningCode schweregradDefiningCode) { + this.schweregradDefiningCode = schweregradDefiningCode; } - public DvCodedText getSchweregrad() { - return this.schweregrad ; + public SchweregradDefiningCode getSchweregradDefiningCode() { + return this.schweregradDefiningCode ; } public void setSchweregradNullFlavourDefiningCode( diff --git a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/VorliegendesSymptomObservationContainment.java b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/VorliegendesSymptomObservationContainment.java index e5fd81e99..686c0f67d 100644 --- a/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/VorliegendesSymptomObservationContainment.java +++ b/src/main/java/org/ehrbase/fhirbridge/ehr/opt/symptomcomposition/definition/VorliegendesSymptomObservationContainment.java @@ -2,7 +2,6 @@ import com.nedap.archie.rm.archetyped.FeederAudit; import com.nedap.archie.rm.datastructures.Cluster; -import com.nedap.archie.rm.datavalues.DvCodedText; import com.nedap.archie.rm.generic.PartyProxy; import java.time.temporal.TemporalAccessor; import org.ehrbase.client.aql.containment.Containment; @@ -16,7 +15,7 @@ public class VorliegendesSymptomObservationContainment extends Containment { public SelectAqlField VORLIEGENDES_SYMPTOM_OBSERVATION = new AqlFieldImp(VorliegendesSymptomObservation.class, "", "VorliegendesSymptomObservation", VorliegendesSymptomObservation.class, this); - public SelectAqlField NAME_DES_SYMPTOMS_KRANKHEITSANZEICHENS = new AqlFieldImp(VorliegendesSymptomObservation.class, "/data[at0190]/events[at0191]/data[at0192]/items[at0001]/value", "nameDesSymptomsKrankheitsanzeichens", DvCodedText.class, this); + public SelectAqlField NAME_DES_SYMPTOMS_KRANKHEITSANZEICHENS_DEFINING_CODE = new AqlFieldImp(VorliegendesSymptomObservation.class, "/data[at0190]/events[at0191]/data[at0192]/items[at0001]/value|defining_code", "nameDesSymptomsKrankheitsanzeichensDefiningCode", NameDesSymptomsKrankheitsanzeichensDefiningCode.class, this); public SelectAqlField NAME_DES_SYMPTOMS_KRANKHEITSANZEICHENS_NULL_FLAVOUR_DEFINING_CODE = new AqlFieldImp(VorliegendesSymptomObservation.class, "/data[at0190]/events[at0191]/data[at0192]/items[at0001]/null_flavour|defining_code", "nameDesSymptomsKrankheitsanzeichensNullFlavourDefiningCode", NullFlavour.class, this); @@ -28,7 +27,7 @@ public class VorliegendesSymptomObservationContainment extends Containment { public SelectAqlField BEGINN_DER_EPISODE_NULL_FLAVOUR_DEFINING_CODE = new AqlFieldImp(VorliegendesSymptomObservation.class, "/data[at0190]/events[at0191]/data[at0192]/items[at0152]/null_flavour|defining_code", "beginnDerEpisodeNullFlavourDefiningCode", NullFlavour.class, this); - public SelectAqlField SCHWEREGRAD = new AqlFieldImp(VorliegendesSymptomObservation.class, "/data[at0190]/events[at0191]/data[at0192]/items[at0021]/value", "schweregrad", DvCodedText.class, this); + public SelectAqlField SCHWEREGRAD_DEFINING_CODE = new AqlFieldImp(VorliegendesSymptomObservation.class, "/data[at0190]/events[at0191]/data[at0192]/items[at0021]/value|defining_code", "schweregradDefiningCode", SchweregradDefiningCode.class, this); public SelectAqlField SCHWEREGRAD_NULL_FLAVOUR_DEFINING_CODE = new AqlFieldImp(VorliegendesSymptomObservation.class, "/data[at0190]/events[at0191]/data[at0192]/items[at0021]/null_flavour|defining_code", "schweregradNullFlavourDefiningCode", NullFlavour.class, this); diff --git a/src/main/resources/opt/Symptom.opt b/src/main/resources/opt/Symptom.opt index 88968e364..7de1da63f 100644 --- a/src/main/resources/opt/Symptom.opt +++ b/src/main/resources/opt/Symptom.opt @@ -1,2724 +1,2693 @@ - - \ No newline at end of file diff --git a/src/main/resources/profiles/SymptomsCovid19-profile.xml b/src/main/resources/profiles/SymptomsCovid19-profile.xml index 61f437c7a..de7b69334 100644 --- a/src/main/resources/profiles/SymptomsCovid19-profile.xml +++ b/src/main/resources/profiles/SymptomsCovid19-profile.xml @@ -1,7421 +1,7423 @@ - - - - - - <status value="active" /> - <date value="2020-10-29" /> - <publisher value="Charité" /> - <contact> - <telecom> - <system value="url" /> - <value value="https://www.bihealth.org/en/research/core-facilities/interoperability/" /> - </telecom> - </contact> - <description value="Symptoms of Covid-19" /> - <fhirVersion value="4.0.1" /> - <mapping> - <identity value="workflow" /> - <uri value="http://hl7.org/fhir/workflow" /> - <name value="Workflow Pattern" /> - </mapping> - <mapping> - <identity value="sct-concept" /> - <uri value="http://snomed.info/conceptdomain" /> - <name value="SNOMED CT Concept Domain Binding" /> - </mapping> - <mapping> - <identity value="v2" /> - <uri value="http://hl7.org/v2" /> - <name value="HL7 v2 Mapping" /> - </mapping> - <mapping> - <identity value="rim" /> - <uri value="http://hl7.org/v3" /> - <name value="RIM Mapping" /> - </mapping> - <mapping> - <identity value="w5" /> - <uri value="http://hl7.org/fhir/fivews" /> - <name value="FiveWs Pattern Mapping" /> - </mapping> - <mapping> - <identity value="sct-attr" /> - <uri value="http://snomed.org/attributebinding" /> - <name value="SNOMED CT Attribute Binding" /> - </mapping> - <kind value="resource" /> - <abstract value="false" /> - <type value="Condition" /> - <baseDefinition value="https://www.netzwerk-universitaetsmedizin.de/fhir/StructureDefinition/gecco-base-condition" /> - <derivation value="constraint" /> - <snapshot> - <element id="Condition"> - <path value="Condition" /> - <short value="Detailed information about conditions, problems or diagnoses" /> - <definition value="A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern." /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Condition" /> - <min value="0" /> - <max value="*" /> - </base> - <constraint> - <key value="dom-2" /> - <severity value="error" /> - <human value="If the resource is contained in another resource, it SHALL NOT contain nested Resources" /> - <expression value="contained.contained.empty()" /> - <xpath value="not(parent::f:contained and f:contained)" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <constraint> - <key value="dom-4" /> - <severity value="error" /> - <human value="If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated" /> - <expression value="contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()" /> - <xpath value="not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <constraint> - <key value="dom-3" /> - <severity value="error" /> - <human value="If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource or SHALL refer to the containing resource" /> - <expression value="contained.where((('#'+id in (%resource.descendants().reference | %resource.descendants().as(canonical) | %resource.descendants().as(uri) | %resource.descendants().as(url))) or descendants().where(reference = '#').exists() or descendants().where(as(canonical) = '#').exists() or descendants().where(as(canonical) = '#').exists()).not()).trace('unmatched', id).empty()" /> - <xpath value="not(exists(for $id in f:contained/*/f:id/@value return $contained[not(parent::*/descendant::f:reference/@value=concat('#', $contained/*/id/@value) or descendant::f:reference[@value='#'])]))" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <constraint> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bestpractice"> - <valueBoolean value="true" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bestpractice-explanation"> - <valueMarkdown value="When a resource has no narrative, only systems that fully understand the data can display the resource to a human safely. Including a human readable representation in the resource makes for a much more robust eco-system and cheaper handling of resources by intermediary systems. Some ecosystems restrict distribution of resources to only those systems that do fully understand the resources, and as a consequence implementers may believe that the narrative is superfluous. However experience shows that such eco-systems often open up to new participants over time." /> - </extension> - <key value="dom-6" /> - <severity value="warning" /> - <human value="A resource should have narrative for robust management" /> - <expression value="text.`div`.exists()" /> - <xpath value="exists(f:text/h:div)" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <constraint> - <key value="dom-5" /> - <severity value="error" /> - <human value="If a resource is contained in another resource, it SHALL NOT have a security label" /> - <expression value="contained.meta.security.empty()" /> - <xpath value="not(exists(f:contained/*/f:meta/f:security))" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <constraint> - <key value="con-5" /> - <severity value="error" /> - <human value="Condition.clinicalStatus SHALL NOT be present if verification Status is entered-in-error" /> - <expression value="verificationStatus.coding.where(system='http://terminology.hl7.org/CodeSystem/condition-ver-status' and code='entered-in-error').empty() or clinicalStatus.empty()" /> - <xpath value="not(exists(f:verificationStatus/f:coding[f:system/@value='http://terminology.hl7.org/CodeSystem/condition-ver-status' and f:code/@value='entered-in-error'])) or not(exists(f:clinicalStatus))" /> - <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> - </constraint> - <constraint> - <key value="con-4" /> - <severity value="error" /> - <human value="If condition is abated, then clinicalStatus must be either inactive, resolved, or remission" /> - <expression value="abatement.empty() or clinicalStatus.coding.where(system='http://terminology.hl7.org/CodeSystem/condition-clinical' and (code='resolved' or code='remission' or code='inactive')).exists()" /> - <xpath value="not(exists(*[starts-with(local-name(.), 'abatement')])) or exists(f:clinicalStatus/f:coding[f:system/@value='http://terminology.hl7.org/CodeSystem/condition-clinical' and f:code/@value=('resolved', 'remission', 'inactive')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> - </constraint> - <constraint> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bestpractice"> - <valueBoolean value="true" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bestpractice-explanation"> - <valueMarkdown value="Most systems will expect a clinicalStatus to be valued for problem-list-items that are managed over time, but might not need a clinicalStatus for point in time encounter-diagnosis." /> - </extension> - <key value="con-3" /> - <severity value="warning" /> - <human value="Condition.clinicalStatus SHALL be present if verificationStatus is not entered-in-error and category is problem-list-item" /> - <expression value="clinicalStatus.exists() or verificationStatus.coding.where(system='http://terminology.hl7.org/CodeSystem/condition-ver-status' and code = 'entered-in-error').exists() or category.select($this='problem-list-item').empty()" /> - <xpath value="exists(f:clinicalStatus) or exists(f:verificationStatus/f:coding/f:code/@value='entered-in-error') or not(exists(category[@value='problem-list-item']))" /> - <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> - </constraint> - <constraint> - <key value="icd-1" /> - <severity value="warning" /> - <human value="Bei Angabe eines Codes in der Haupt-Kreuz-Extension, muss dieser auch Bestandteil des postkoordinierten ICD-Codes sein!" /> - <expression value="extension('https://www.medizininformatik-initiative.de/fhir/core/StructureDefinition/icd-10-gm-primaercode').empty() or code.contains($this.extension('https://www.medizininformatik-initiative.de/fhir/core/StructureDefinition/icd-10-gm-primaercode').value.code)" /> - <source value="https://www.medizininformatik-initiative.de/fhir/core/modul-diagnose/StructureDefinition/Diagnose" /> - </constraint> - <constraint> - <key value="icd-2" /> - <severity value="warning" /> - <human value="Bei Angabe eines Codes in der Stern-Extension, muss dieser auch Bestandteil des postkoordinierten ICD-Codes sein!" /> - <expression value="extension('https://www.medizininformatik-initiative.de/fhir/core/StructureDefinition/icd-10-gm-manifestation').empty() or code.contains($this.extension('https://www.medizininformatik-initiative.de/fhir/core/StructureDefinition/icd-10-gm-manifestation').value.code)" /> - <source value="https://www.medizininformatik-initiative.de/fhir/core/modul-diagnose/StructureDefinition/Diagnose" /> - </constraint> - <constraint> - <key value="icd-3" /> - <severity value="warning" /> - <human value="Bei Angabe eines Codes in der Ausrufezeichen-Extension, muss dieser auch Bestandteil des postkoordinierten ICD-Codes sein!" /> - <expression value="extension('http://fhir.de/StructureDefinition/icd-10-gm-ausrufezeichen').empty() or code.contains($this.extension('http://fhir.de/StructureDefinition/icd-10-gm-ausrufezeichen').value.code)" /> - <source value="https://www.medizininformatik-initiative.de/fhir/core/modul-diagnose/StructureDefinition/Diagnose" /> - </constraint> - <constraint> - <key value="icd-8" /> - <severity value="warning" /> - <human value="Bei Angabe eines Codes in der Seitenlokalisations-Extension, muss dieser auch Bestandteil des ICD-Codes sein!" /> - <expression value="extension('http://fhir.de/StructureDefinition/seitenlokalisation').empty() or code.contains($this.extension('http://fhir.de/StructureDefinition/seitenlokalisation').value.code)" /> - <source value="https://www.medizininformatik-initiative.de/fhir/core/modul-diagnose/StructureDefinition/Diagnose" /> - </constraint> - <constraint> - <key value="unk-1" /> - <severity value="error" /> - <human value="If verificationStatus is present, uncertaintyOfPresence-Extension SHALL NOT be present." /> - <expression value="verificationStatus.exists() != Condition.extension.where(url = 'https://www.netzwerk-universitaetsmedizin.de/fhir/StructureDefinition/uncertainty-of-presence').exists()" /> - <source value="https://www.netzwerk-universitaetsmedizin.de/fhir/StructureDefinition/gecco-base-condition" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="Entity. Role, or Act" /> - </mapping> - <mapping> - <identity value="workflow" /> - <map value="Event" /> - </mapping> - <mapping> - <identity value="sct-concept" /> - <map value="< 243796009 |Situation with explicit context| : 246090004 |Associated finding| = ( ( < 404684003 |Clinical finding| MINUS ( << 420134006 |Propensity to adverse reactions| OR << 473010000 |Hypersensitivity condition| OR << 79899007 |Drug interaction| OR << 69449002 |Drug action| OR << 441742003 |Evaluation finding| OR << 307824009 |Administrative status| OR << 385356007 |Tumor stage finding|)) OR < 272379006 |Event|)" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="PPR message" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="Observation[classCode=OBS, moodCode=EVN, code=ASSERTION, value<Diagnosis]" /> - </mapping> - </element> - <element id="Condition.id"> - <path value="Condition.id" /> - <short value="Logical id of this artifact" /> - <definition value="The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes." /> - <comment value="The only time that a resource does not have an id is when it is being submitted to the server using a create operation." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Resource.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mustSupport value="true" /> - <isSummary value="true" /> - </element> - <element id="Condition.meta"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.meta" /> - <short value="Metadata about the resource" /> - <definition value="The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Resource.meta" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="Meta" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.meta.id"> - <path value="Condition.meta.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.meta.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.meta.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.meta.versionId"> - <path value="Condition.meta.versionId" /> - <short value="Version specific identifier" /> - <definition value="The version specific identifier, as it appears in the version portion of the URL. This value changes when the resource is created, updated, or deleted." /> - <comment value="The server assigns this value, and ignores what the client specifies, except in the case that the server is imposing version integrity on updates/deletes." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Meta.versionId" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="id" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.meta.lastUpdated"> - <path value="Condition.meta.lastUpdated" /> - <short value="When the resource version last changed" /> - <definition value="When the resource last changed - e.g. when the version changed." /> - <comment value="This value is always populated except when the resource is first being created. The server / resource manager sets this value; what a client provides is irrelevant. This is equivalent to the HTTP Last-Modified and SHOULD have the same value on a [read](http.html#read) interaction." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Meta.lastUpdated" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="instant" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.meta.source"> - <path value="Condition.meta.source" /> - <short value="Identifies where the resource comes from" /> - <definition value="A uri that identifies the source system of the resource. This provides a minimal amount of [Provenance](provenance.html#) information that can be used to track or differentiate the source of information in the resource. The source may identify another FHIR server, document, message, database, etc." /> - <comment value="In the provenance resource, this corresponds to Provenance.entity.what[x]. The exact use of the source (and the implied Provenance.entity.role) is left to implementer discretion. Only one nominated source is allowed; for additional provenance details, a full Provenance resource should be used. This element can be used to indicate where the current master source of a resource that has a canonical URL if the resource is no longer hosted at the canonical URL." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Meta.source" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="uri" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.meta.profile"> - <path value="Condition.meta.profile" /> - <short value="Profiles this resource claims to conform to" /> - <definition value="A list of profiles (references to [StructureDefinition](structuredefinition.html#) resources) that this resource claims to conform to. The URL is a reference to [StructureDefinition.url](structuredefinition-definitions.html#StructureDefinition.url)." /> - <comment value="It is up to the server and/or other infrastructure of policy to determine whether/how these claims are verified and/or updated over time. The list of profile URLs is a set." /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Meta.profile" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="canonical" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/StructureDefinition" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.meta.security"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.meta.security" /> - <short value="Security Labels applied to this resource" /> - <definition value="Security labels applied to this resource. These tags connect specific resources to the overall security policy and infrastructure." /> - <comment value="The security labels can be updated without changing the stated version of the resource. The list of security labels is a set. Uniqueness is based the system/code, and version and display are ignored." /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Meta.security" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Coding" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <binding> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> - <valueString value="SecurityLabels" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding"> - <valueBoolean value="true" /> - </extension> - <strength value="extensible" /> - <description value="Security Labels from the Healthcare Privacy and Security Classification System." /> - <valueSet value="http://hl7.org/fhir/ValueSet/security-labels" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> - </mapping> - </element> - <element id="Condition.meta.tag"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.meta.tag" /> - <short value="Tags applied to this resource" /> - <definition value="Tags applied to this resource. Tags are intended to be used to identify and relate resources to process and workflow, and applications are not required to consider the tags when interpreting the meaning of a resource." /> - <comment value="The tags can be updated without changing the stated version of the resource. The list of tags is a set. Uniqueness is based the system/code, and version and display are ignored." /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Meta.tag" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Coding" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <binding> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> - <valueString value="Tags" /> - </extension> - <strength value="example" /> - <description value="Codes that represent various types of tags, commonly workflow-related; e.g. "Needs review by Dr. Jones"." /> - <valueSet value="http://hl7.org/fhir/ValueSet/common-tags" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> - </mapping> - </element> - <element id="Condition.implicitRules"> - <path value="Condition.implicitRules" /> - <short value="A set of rules under which this content was created" /> - <definition value="A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content. Often, this is a reference to an implementation guide that defines the special rules along with other profiles etc." /> - <comment value="Asserting this rule set restricts the content to be only understood by a limited set of trading partners. This inherently limits the usefulness of the data in the long term. However, the existing health eco-system is highly fractured, and not yet ready to define, collect, and exchange data in a generally computable sense. Wherever possible, implementers and/or specification writers should avoid using this element. Often, when used, the URL is a reference to an implementation guide that defines these special rules as part of it's narrative along with other profiles, value sets, etc." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Resource.implicitRules" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="uri" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isModifier value="true" /> - <isModifierReason value="This element is labeled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.language"> - <path value="Condition.language" /> - <short value="Language of the resource content" /> - <definition value="The base language in which the resource is written." /> - <comment value="Language is provided to support indexing and accessibility (typically, services such as text to speech use the language tag). The html language tag in the narrative applies to the narrative. The language tag on the resource may be used to specify the language of other presentations generated from the data in the resource. Not all the content has to be in the base language. The Resource.language should not be assumed to apply to the narrative automatically. If a language is specified, it should it also be specified on the div element in the html (see rules in HTML5 for information about the relationship between xml:lang and the html lang attribute)." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Resource.language" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="code" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <binding> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet"> - <valueCanonical value="http://hl7.org/fhir/ValueSet/all-languages" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> - <valueString value="Language" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding"> - <valueBoolean value="true" /> - </extension> - <strength value="preferred" /> - <description value="A human language." /> - <valueSet value="http://hl7.org/fhir/ValueSet/languages" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.text"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.text" /> - <short value="Text summary of the resource, for human interpretation" /> - <definition value="A human-readable narrative that contains a summary of the resource and can be used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it "clinically safe" for a human to just read the narrative. Resource definitions may define what content should be represented in the narrative to ensure clinical safety." /> - <comment value="Contained resources do not have narrative. Resources that are not contained SHOULD have a narrative. In some cases, a resource may only have text with little or no additional discrete data (as long as all minOccurs=1 elements are satisfied). This may be necessary for data from legacy systems where information is captured as a "text blob" or where text is additionally entered raw or narrated and encoded information is added later." /> - <alias value="narrative" /> - <alias value="html" /> - <alias value="xhtml" /> - <alias value="display" /> - <min value="0" /> - <max value="1" /> - <base> - <path value="DomainResource.text" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="Narrative" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="Act.text?" /> - </mapping> - </element> - <element id="Condition.contained"> - <path value="Condition.contained" /> - <short value="Contained, inline Resources" /> - <definition value="These resources do not have an independent existence apart from the resource that contains them - they cannot be identified independently, and nor can they have their own independent transaction scope." /> - <comment value="This should never be done when the content can be identified properly, as once identification is lost, it is extremely difficult (and context dependent) to restore it again. Contained resources may have profiles and tags In their meta elements, but SHALL NOT have security labels." /> - <alias value="inline resources" /> - <alias value="anonymous resources" /> - <alias value="contained resources" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="DomainResource.contained" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Resource" /> - </type> - <mapping> - <identity value="rim" /> - <map value="Entity. Role, or Act" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the resource. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="DomainResource.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.extension:uncertaintyOfPresence"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.extension" /> - <sliceName value="uncertaintyOfPresence" /> - <short value="Uncertainty of presence" /> - <definition value="Extension used on a condition resource if the presence of the condition is unknown." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="1" /> - <base> - <path value="DomainResource.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - <profile value="https://www.netzwerk-universitaetsmedizin.de/fhir/StructureDefinition/uncertainty-of-presence" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mustSupport value="true" /> - <isModifier value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.modifierExtension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.modifierExtension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Extensions that cannot be ignored" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the resource and that modifies the understanding of the element that contains it and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions. Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself)." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <requirements value="Modifier extensions allow for extensions that *cannot* be safely ignored to be clearly distinguished from the vast majority of extensions which can be safely ignored. This promotes interoperability by eliminating the need for implementers to prohibit the presence of extensions. For further information, see the [definition of modifier extensions](extensibility.html#modifierExtension)." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="DomainResource.modifierExtension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <isModifier value="true" /> - <isModifierReason value="Modifier extensions are expected to modify the meaning or interpretation of the resource that contains them" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.identifier"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.identifier" /> - <short value="External Ids for this condition" /> - <definition value="Business identifiers assigned to this condition by the performer or other systems which remain constant as the resource is updated and propagates from server to server." /> - <comment value="This is a business identifier, not a resource identifier (see [discussion](resource.html#identifiers)). It is best practice for the identifier to only appear on a single resource instance, however business practices may occasionally dictate that multiple resource instances with the same identifier can exist - possibly even with different resource types. For example, multiple Patient and a Person resource instance might share the same social insurance number." /> - <requirements value="Allows identification of the condition as it is known by various participating systems and in a way that remains consistent across servers." /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Condition.identifier" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Identifier" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CX / EI (occasionally, more often EI maps to a resource id or a URL)" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="II - The Identifier class is a little looser than the v3 type II because it allows URIs as well as registered OIDs or GUIDs. Also maps to Role[classCode=IDENT]" /> - </mapping> - <mapping> - <identity value="servd" /> - <map value="Identifier" /> - </mapping> - <mapping> - <identity value="workflow" /> - <map value="Event.identifier" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.identifier" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".id" /> - </mapping> - </element> - <element id="Condition.clinicalStatus"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.clinicalStatus" /> - <short value="active | recurrence | relapse | inactive | remission | resolved" /> - <definition value="The clinical status of the condition." /> - <comment value="The data type is CodeableConcept because clinicalStatus has some clinical judgment involved, such that there might need to be more specificity than the required FHIR value set allows. For example, a SNOMED coding might allow for additional specificity." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Condition.clinicalStatus" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="CodeableConcept" /> - </type> - <condition value="ele-1" /> - <condition value="con-3" /> - <condition value="con-4" /> - <condition value="con-5" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isModifier value="true" /> - <isModifierReason value="This element is labeled as a modifier because the status contains codes that mark the condition as no longer active." /> - <isSummary value="true" /> - <binding> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> - <valueString value="ConditionClinicalStatus" /> - </extension> - <strength value="required" /> - <description value="The clinical status of the condition or diagnosis." /> - <valueSet value="http://hl7.org/fhir/ValueSet/condition-clinical|4.0.1" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> - </mapping> - <mapping> - <identity value="workflow" /> - <map value="Event.status" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.status" /> - </mapping> - <mapping> - <identity value="sct-concept" /> - <map value="< 303105007 |Disease phases|" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="PRB-14" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="Observation ACT .inboundRelationship[typeCode=COMP].source[classCode=OBS, code="clinicalStatus", moodCode=EVN].value" /> - </mapping> - </element> - <element id="Condition.verificationStatus"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.verificationStatus" /> - <short value="unconfirmed | provisional | differential | confirmed | refuted | entered-in-error" /> - <definition value="The verification status to support the clinical status of the condition." /> - <comment value="verificationStatus is not required. For example, when a patient has abdominal pain in the ED, there is not likely going to be a verification status. The data type is CodeableConcept because verificationStatus has some clinical judgment involved, such that there might need to be more specificity than the required FHIR value set allows. For example, a SNOMED coding might allow for additional specificity." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Condition.verificationStatus" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="CodeableConcept" /> - </type> - <condition value="ele-1" /> - <condition value="con-3" /> - <condition value="con-5" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isModifier value="true" /> - <isModifierReason value="This element is labeled as a modifier because the status contains the code refuted and entered-in-error that mark the Condition as not currently valid." /> - <isSummary value="true" /> - <binding> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> - <valueString value="ConditionVerificationStatus" /> - </extension> - <strength value="required" /> - <description value="The verification status to support or decline the clinical status of the condition or diagnosis." /> - <valueSet value="http://hl7.org/fhir/ValueSet/condition-ver-status|4.0.1" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> - </mapping> - <mapping> - <identity value="workflow" /> - <map value="Event.status" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.status" /> - </mapping> - <mapping> - <identity value="sct-concept" /> - <map value="< 410514004 |Finding context value|" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="PRB-13" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="Observation ACT .inboundRelationship[typeCode=COMP].source[classCode=OBS, code="verificationStatus", moodCode=EVN].value" /> - </mapping> - <mapping> - <identity value="sct-attr" /> - <map value="408729009" /> - </mapping> - </element> - <element id="Condition.verificationStatus.id"> - <path value="Condition.verificationStatus.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.verificationStatus.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.verificationStatus.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.verificationStatus.coding" /> - <slicing> - <discriminator> - <type value="pattern" /> - <path value="$this" /> - </discriminator> - <rules value="open" /> - </slicing> - <short value="Code defined by a terminology system" /> - <definition value="A reference to a code defined by a terminology system." /> - <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> - <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> - <min value="1" /> - <max value="*" /> - <base> - <path value="CodeableConcept.coding" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Coding" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1-8, C*E.10-22" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="union(., ./translation)" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:conditionVerificationStatus"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.verificationStatus.coding" /> - <sliceName value="conditionVerificationStatus" /> - <short value="Code defined by a terminology system" /> - <definition value="A reference to a code defined by a terminology system." /> - <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> - <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="CodeableConcept.coding" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Coding" /> - </type> - <patternCoding> - <system value="http://terminology.hl7.org/CodeSystem/condition-ver-status" /> - </patternCoding> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1-8, C*E.10-22" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="union(., ./translation)" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:conditionVerificationStatus.id"> - <path value="Condition.verificationStatus.coding.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:conditionVerificationStatus.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.verificationStatus.coding.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:conditionVerificationStatus.system"> - <path value="Condition.verificationStatus.coding.system" /> - <short value="Identity of the terminology system" /> - <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> - <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> - <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.system" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="uri" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.3" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystem" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:conditionVerificationStatus.version"> - <path value="Condition.verificationStatus.coding.version" /> - <short value="Version of the system - if relevant" /> - <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> - <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.version" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.7" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystemVersion" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:conditionVerificationStatus.code"> - <path value="Condition.verificationStatus.coding.code" /> - <short value="Symbol in syntax defined by the system" /> - <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to refer to a particular code in the system." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.code" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="code" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./code" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:conditionVerificationStatus.display"> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> - <valueBoolean value="true" /> - </extension> - <path value="Condition.verificationStatus.coding.display" /> - <short value="Representation defined by the system" /> - <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.display" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.2 - but note this is not well followed" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV.displayName" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:conditionVerificationStatus.userSelected"> - <path value="Condition.verificationStatus.coding.userSelected" /> - <short value="If this coding was chosen directly by the user" /> - <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> - <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> - <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.userSelected" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="boolean" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="Sometimes implied by being first" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD.codingRationale" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:snomed"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.verificationStatus.coding" /> - <sliceName value="snomed" /> - <short value="Code defined by a terminology system" /> - <definition value="A reference to a code defined by a terminology system." /> - <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> - <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="CodeableConcept.coding" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Coding" /> - </type> - <patternCoding> - <system value="http://snomed.info/sct" /> - </patternCoding> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <binding> - <strength value="required" /> - <description value="Confirmed present | Definitely NOT present" /> - <valueSet value="https://www.netzwerk-universitaetsmedizin.de/fhir/ValueSet/verification-status" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1-8, C*E.10-22" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="union(., ./translation)" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:snomed.id"> - <path value="Condition.verificationStatus.coding.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:snomed.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.verificationStatus.coding.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:snomed.system"> - <path value="Condition.verificationStatus.coding.system" /> - <short value="Identity of the terminology system" /> - <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> - <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> - <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.system" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="uri" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.3" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystem" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:snomed.version"> - <path value="Condition.verificationStatus.coding.version" /> - <short value="Version of the system - if relevant" /> - <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> - <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.version" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.7" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystemVersion" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:snomed.code"> - <path value="Condition.verificationStatus.coding.code" /> - <short value="Symbol in syntax defined by the system" /> - <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to refer to a particular code in the system." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.code" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="code" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./code" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:snomed.display"> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> - <valueBoolean value="true" /> - </extension> - <path value="Condition.verificationStatus.coding.display" /> - <short value="Representation defined by the system" /> - <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.display" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.2 - but note this is not well followed" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV.displayName" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> - </mapping> - </element> - <element id="Condition.verificationStatus.coding:snomed.userSelected"> - <path value="Condition.verificationStatus.coding.userSelected" /> - <short value="If this coding was chosen directly by the user" /> - <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> - <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> - <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.userSelected" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="boolean" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="Sometimes implied by being first" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD.codingRationale" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> - </mapping> - </element> - <element id="Condition.verificationStatus.text"> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> - <valueBoolean value="true" /> - </extension> - <path value="Condition.verificationStatus.text" /> - <short value="Plain text representation of the concept" /> - <definition value="A human language representation of the concept as seen/selected/uttered by the user who entered the data and/or which represents the intended meaning of the user." /> - <comment value="Very often the text is the same as a displayName of one of the codings." /> - <requirements value="The codes from the terminologies do not always capture the correct meaning with all the nuances of the human using them, or sometimes there is no appropriate code at all. In these cases, the text is used to capture the full meaning of the source." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="CodeableConcept.text" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.9. But note many systems use C*E.2 for this" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./originalText[mediaType/code="text/plain"]/data" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.text rdfs:subPropertyOf dt:CD.originalText" /> - </mapping> - </element> - <element id="Condition.category"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.category" /> - <short value="problem-list-item | encounter-diagnosis" /> - <definition value="A category assigned to the condition." /> - <comment value="The categorization is often highly contextual and may appear poorly differentiated or not very useful in other contexts." /> - <min value="1" /> - <max value="*" /> - <base> - <path value="Condition.category" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="CodeableConcept" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <binding> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> - <valueString value="ConditionCategory" /> - </extension> - <strength value="extensible" /> - <description value="A category assigned to the condition." /> - <valueSet value="http://hl7.org/fhir/ValueSet/condition-category" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.class" /> - </mapping> - <mapping> - <identity value="sct-concept" /> - <map value="< 404684003 |Clinical finding|" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="'problem' if from PRB-3. 'diagnosis' if from DG1 segment in PV1 message" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".code" /> - </mapping> - </element> - <element id="Condition.category.id"> - <path value="Condition.category.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.category.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.category.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.category.coding"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.category.coding" /> - <slicing> - <discriminator> - <type value="pattern" /> - <path value="$this" /> - </discriminator> - <rules value="open" /> - </slicing> - <short value="Code defined by a terminology system" /> - <definition value="A reference to a code defined by a terminology system." /> - <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> - <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> - <min value="1" /> - <max value="*" /> - <base> - <path value="CodeableConcept.coding" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Coding" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1-8, C*E.10-22" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="union(., ./translation)" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> - </mapping> - </element> - <element id="Condition.category.coding:symptoms"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.category.coding" /> - <sliceName value="symptoms" /> - <short value="Code defined by a terminology system" /> - <definition value="A reference to a code defined by a terminology system." /> - <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> - <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="CodeableConcept.coding" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Coding" /> - </type> - <patternCoding> - <system value="http://loinc.org" /> - <code value="75325-1" /> - </patternCoding> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1-8, C*E.10-22" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="union(., ./translation)" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> - </mapping> - </element> - <element id="Condition.category.coding:symptoms.id"> - <path value="Condition.category.coding.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.category.coding:symptoms.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.category.coding.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.category.coding:symptoms.system"> - <path value="Condition.category.coding.system" /> - <short value="Identity of the terminology system" /> - <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> - <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> - <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.system" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="uri" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.3" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystem" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> - </mapping> - </element> - <element id="Condition.category.coding:symptoms.version"> - <path value="Condition.category.coding.version" /> - <short value="Version of the system - if relevant" /> - <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> - <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.version" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.7" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystemVersion" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> - </mapping> - </element> - <element id="Condition.category.coding:symptoms.code"> - <path value="Condition.category.coding.code" /> - <short value="Symbol in syntax defined by the system" /> - <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to refer to a particular code in the system." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.code" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="code" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./code" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> - </mapping> - </element> - <element id="Condition.category.coding:symptoms.display"> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> - <valueBoolean value="true" /> - </extension> - <path value="Condition.category.coding.display" /> - <short value="Representation defined by the system" /> - <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.display" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.2 - but note this is not well followed" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV.displayName" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> - </mapping> - </element> - <element id="Condition.category.coding:symptoms.userSelected"> - <path value="Condition.category.coding.userSelected" /> - <short value="If this coding was chosen directly by the user" /> - <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> - <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> - <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.userSelected" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="boolean" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="Sometimes implied by being first" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD.codingRationale" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> - </mapping> - </element> - <element id="Condition.category.text"> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> - <valueBoolean value="true" /> - </extension> - <path value="Condition.category.text" /> - <short value="Plain text representation of the concept" /> - <definition value="A human language representation of the concept as seen/selected/uttered by the user who entered the data and/or which represents the intended meaning of the user." /> - <comment value="Very often the text is the same as a displayName of one of the codings." /> - <requirements value="The codes from the terminologies do not always capture the correct meaning with all the nuances of the human using them, or sometimes there is no appropriate code at all. In these cases, the text is used to capture the full meaning of the source." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="CodeableConcept.text" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.9. But note many systems use C*E.2 for this" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./originalText[mediaType/code="text/plain"]/data" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.text rdfs:subPropertyOf dt:CD.originalText" /> - </mapping> - </element> - <element id="Condition.severity"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.severity" /> - <short value="Subjective severity of condition" /> - <definition value="A subjective assessment of the severity of the condition as evaluated by the clinician." /> - <comment value="Coding of the severity with a terminology is preferred, where possible." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Condition.severity" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="CodeableConcept" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <binding> - <strength value="preferred" /> - <description value="A subjective assessment of the severity of the condition as evaluated by the clinician." /> - <valueSet value="https://www.netzwerk-universitaetsmedizin.de/fhir/ValueSet/condition-severity" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.grade" /> - </mapping> - <mapping> - <identity value="sct-concept" /> - <map value="< 272141005 |Severities|" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="PRB-26 / ABS-3" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="Can be pre/post-coordinated into value. Or ./inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="severity"].value" /> - </mapping> - <mapping> - <identity value="sct-attr" /> - <map value="246112005" /> - </mapping> - </element> - <element id="Condition.code"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code" /> - <short value="Identification of the condition, problem or diagnosis" /> - <definition value="Identification of the condition, problem or diagnosis." /> - <comment value="Not all terminology uses fit this general pattern. In some cases, models should not use CodeableConcept and use Coding directly and provide their own structure for managing text, codings, translations and the relationship between elements and pre- and post-coordination." /> - <requirements value="0..1 to account for primarily narrative only resources." /> - <alias value="type" /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Condition.code" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="CodeableConcept" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <binding> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> - <valueString value="ConditionKind" /> - </extension> - <strength value="example" /> - <description value="Identification of the condition or diagnosis." /> - <valueSet value="http://hl7.org/fhir/ValueSet/condition-code" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> - </mapping> - <mapping> - <identity value="workflow" /> - <map value="Event.code" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.what[x]" /> - </mapping> - <mapping> - <identity value="sct-concept" /> - <map value="code 246090004 |Associated finding| (< 404684003 |Clinical finding| MINUS << 420134006 |Propensity to adverse reactions| MINUS << 473010000 |Hypersensitivity condition| MINUS << 79899007 |Drug interaction| MINUS << 69449002 |Drug action| MINUS << 441742003 |Evaluation finding| MINUS << 307824009 |Administrative status| MINUS << 385356007 |Tumor stage finding|) OR < 413350009 |Finding with explicit context| OR < 272379006 |Event|" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="PRB-3" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".value" /> - </mapping> - <mapping> - <identity value="sct-attr" /> - <map value="246090004" /> - </mapping> - </element> - <element id="Condition.code.id"> - <path value="Condition.code.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.code.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.code.coding"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.coding" /> - <slicing> - <discriminator> - <type value="pattern" /> - <path value="$this" /> - </discriminator> - <rules value="open" /> - </slicing> - <short value="Code defined by a terminology system" /> - <definition value="A reference to a code defined by a terminology system." /> - <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> - <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> - <min value="1" /> - <max value="*" /> - <base> - <path value="CodeableConcept.coding" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Coding" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1-8, C*E.10-22" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="union(., ./translation)" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> - </mapping> - </element> - <element id="Condition.code.coding:icd10-gm"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.coding" /> - <sliceName value="icd10-gm" /> - <short value="Code defined by a terminology system" /> - <definition value="A reference to a code defined by a terminology system." /> - <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> - <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="CodeableConcept.coding" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Coding" /> - </type> - <patternCoding> - <system value="http://fhir.de/CodeSystem/dimdi/icd-10-gm" /> - </patternCoding> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <binding> - <strength value="required" /> - <valueSet value="http://fhir.de/ValueSet/dimdi/icd-10-gm" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1-8, C*E.10-22" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="union(., ./translation)" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> - </mapping> - </element> - <element id="Condition.code.coding:icd10-gm.id"> - <path value="Condition.code.coding.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.code.coding:icd10-gm.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.coding.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.code.coding:icd10-gm.extension:Diagnosesicherheit"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.coding.extension" /> - <sliceName value="Diagnosesicherheit" /> - <short value="Optional Extensions Element" /> - <definition value="Optional Extension Element - found in all resources." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - <profile value="http://fhir.de/StructureDefinition/icd-10-gm-diagnosesicherheit" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mustSupport value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.code.coding:icd10-gm.extension:Seitenlokalisation"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.coding.extension" /> - <sliceName value="Seitenlokalisation" /> - <short value="Optional Extensions Element" /> - <definition value="Optional Extension Element - found in all resources." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - <profile value="http://fhir.de/StructureDefinition/seitenlokalisation" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mustSupport value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.code.coding:icd10-gm.extension:AusrufezeichenCode"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.coding.extension" /> - <sliceName value="AusrufezeichenCode" /> - <short value="Optional Extensions Element" /> - <definition value="Optional Extension Element - found in all resources." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - <profile value="http://fhir.de/StructureDefinition/icd-10-gm-ausrufezeichen" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mustSupport value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.code.coding:icd10-gm.extension:ManifestationsCode"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.coding.extension" /> - <sliceName value="ManifestationsCode" /> - <short value="Optional Extensions Element" /> - <definition value="Optional Extension Element - found in all resources." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - <profile value="http://fhir.de/StructureDefinition/icd-10-gm-manifestationscode" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mustSupport value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.code.coding:icd10-gm.extension:Primaercode"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.coding.extension" /> - <sliceName value="Primaercode" /> - <short value="Optional Extensions Element" /> - <definition value="Optional Extension Element - found in all resources." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - <profile value="http://fhir.de/StructureDefinition/icd-10-gm-primaercode" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mustSupport value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.code.coding:icd10-gm.system"> - <path value="Condition.code.coding.system" /> - <short value="Identity of the terminology system" /> - <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> - <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> - <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.system" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="uri" /> - </type> - <patternUri value="http://fhir.de/CodeSystem/dimdi/icd-10-gm" /> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.3" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystem" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> - </mapping> - </element> - <element id="Condition.code.coding:icd10-gm.version"> - <path value="Condition.code.coding.version" /> - <short value="Version of the system - if relevant" /> - <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> - <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.version" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.7" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystemVersion" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> - </mapping> - </element> - <element id="Condition.code.coding:icd10-gm.code"> - <path value="Condition.code.coding.code" /> - <short value="Symbol in syntax defined by the system" /> - <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to refer to a particular code in the system." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.code" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="code" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./code" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> - </mapping> - </element> - <element id="Condition.code.coding:icd10-gm.display"> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> - <valueBoolean value="true" /> - </extension> - <path value="Condition.code.coding.display" /> - <short value="Representation defined by the system" /> - <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.display" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.2 - but note this is not well followed" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV.displayName" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> - </mapping> - </element> - <element id="Condition.code.coding:icd10-gm.userSelected"> - <path value="Condition.code.coding.userSelected" /> - <short value="If this coding was chosen directly by the user" /> - <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> - <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> - <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.userSelected" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="boolean" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="Sometimes implied by being first" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD.codingRationale" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> - </mapping> - </element> - <element id="Condition.code.coding:alpha-id"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.coding" /> - <sliceName value="alpha-id" /> - <short value="Code defined by a terminology system" /> - <definition value="A reference to a code defined by a terminology system." /> - <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> - <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="CodeableConcept.coding" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Coding" /> - </type> - <patternCoding> - <system value="http://fhir.de/CodeSystem/dimdi/alpha-id" /> - </patternCoding> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <binding> - <strength value="required" /> - <valueSet value="http://fhir.de/ValueSet/dimdi/alpha-id" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1-8, C*E.10-22" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="union(., ./translation)" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> - </mapping> - </element> - <element id="Condition.code.coding:alpha-id.id"> - <path value="Condition.code.coding.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.code.coding:alpha-id.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.coding.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.code.coding:alpha-id.system"> - <path value="Condition.code.coding.system" /> - <short value="Identity of the terminology system" /> - <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> - <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> - <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.system" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="uri" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.3" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystem" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> - </mapping> - </element> - <element id="Condition.code.coding:alpha-id.version"> - <path value="Condition.code.coding.version" /> - <short value="Version of the system - if relevant" /> - <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> - <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.version" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.7" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystemVersion" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> - </mapping> - </element> - <element id="Condition.code.coding:alpha-id.code"> - <path value="Condition.code.coding.code" /> - <short value="Symbol in syntax defined by the system" /> - <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to refer to a particular code in the system." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.code" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="code" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./code" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> - </mapping> - </element> - <element id="Condition.code.coding:alpha-id.display"> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> - <valueBoolean value="true" /> - </extension> - <path value="Condition.code.coding.display" /> - <short value="Representation defined by the system" /> - <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.display" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.2 - but note this is not well followed" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV.displayName" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> - </mapping> - </element> - <element id="Condition.code.coding:alpha-id.userSelected"> - <path value="Condition.code.coding.userSelected" /> - <short value="If this coding was chosen directly by the user" /> - <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> - <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> - <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.userSelected" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="boolean" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="Sometimes implied by being first" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD.codingRationale" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> - </mapping> - </element> - <element id="Condition.code.coding:sct"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.coding" /> - <sliceName value="sct" /> - <short value="Code defined by a terminology system" /> - <definition value="A reference to a code defined by a terminology system." /> - <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> - <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="CodeableConcept.coding" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Coding" /> - </type> - <patternCoding> - <system value="http://snomed.info/sct" /> - </patternCoding> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <binding> - <strength value="required" /> - <valueSet value="https://www.netzwerk-universitaetsmedizin.de/fhir/ValueSet/sars-cov-2-symptoms" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1-8, C*E.10-22" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="union(., ./translation)" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> - </mapping> - </element> - <element id="Condition.code.coding:sct.id"> - <path value="Condition.code.coding.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.code.coding:sct.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.coding.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.code.coding:sct.system"> - <path value="Condition.code.coding.system" /> - <short value="Identity of the terminology system" /> - <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> - <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> - <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.system" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="uri" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.3" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystem" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> - </mapping> - </element> - <element id="Condition.code.coding:sct.version"> - <path value="Condition.code.coding.version" /> - <short value="Version of the system - if relevant" /> - <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> - <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.version" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.7" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystemVersion" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> - </mapping> - </element> - <element id="Condition.code.coding:sct.code"> - <path value="Condition.code.coding.code" /> - <short value="Symbol in syntax defined by the system" /> - <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to refer to a particular code in the system." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.code" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="code" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./code" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> - </mapping> - </element> - <element id="Condition.code.coding:sct.display"> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> - <valueBoolean value="true" /> - </extension> - <path value="Condition.code.coding.display" /> - <short value="Representation defined by the system" /> - <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.display" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.2 - but note this is not well followed" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV.displayName" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> - </mapping> - </element> - <element id="Condition.code.coding:sct.userSelected"> - <path value="Condition.code.coding.userSelected" /> - <short value="If this coding was chosen directly by the user" /> - <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> - <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> - <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.userSelected" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="boolean" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="Sometimes implied by being first" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD.codingRationale" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> - </mapping> - </element> - <element id="Condition.code.coding:orphanet"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.coding" /> - <sliceName value="orphanet" /> - <short value="Code defined by a terminology system" /> - <definition value="A reference to a code defined by a terminology system." /> - <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> - <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> - <min value="0" /> - <max value="0" /> - <base> - <path value="CodeableConcept.coding" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Coding" /> - </type> - <patternCoding> - <system value="http://www.orpha.net" /> - </patternCoding> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1-8, C*E.10-22" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="union(., ./translation)" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> - </mapping> - </element> - <element id="Condition.code.coding:orphanet.id"> - <path value="Condition.code.coding.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.code.coding:orphanet.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.code.coding.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.code.coding:orphanet.system"> - <path value="Condition.code.coding.system" /> - <short value="Identity of the terminology system" /> - <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> - <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> - <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.system" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="uri" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.3" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystem" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> - </mapping> - </element> - <element id="Condition.code.coding:orphanet.version"> - <path value="Condition.code.coding.version" /> - <short value="Version of the system - if relevant" /> - <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> - <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.version" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.7" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystemVersion" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> - </mapping> - </element> - <element id="Condition.code.coding:orphanet.code"> - <path value="Condition.code.coding.code" /> - <short value="Symbol in syntax defined by the system" /> - <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to refer to a particular code in the system." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.code" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="code" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./code" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> - </mapping> - </element> - <element id="Condition.code.coding:orphanet.display"> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> - <valueBoolean value="true" /> - </extension> - <path value="Condition.code.coding.display" /> - <short value="Representation defined by the system" /> - <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.display" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.2 - but note this is not well followed" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV.displayName" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> - </mapping> - </element> - <element id="Condition.code.coding:orphanet.userSelected"> - <path value="Condition.code.coding.userSelected" /> - <short value="If this coding was chosen directly by the user" /> - <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> - <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> - <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.userSelected" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="boolean" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="Sometimes implied by being first" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD.codingRationale" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> - </mapping> - </element> - <element id="Condition.code.text"> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> - <valueBoolean value="true" /> - </extension> - <path value="Condition.code.text" /> - <short value="Plain text representation of the concept" /> - <definition value="A human language representation of the concept as seen/selected/uttered by the user who entered the data and/or which represents the intended meaning of the user." /> - <comment value="Very often the text is the same as a displayName of one of the codings." /> - <requirements value="The codes from the terminologies do not always capture the correct meaning with all the nuances of the human using them, or sometimes there is no appropriate code at all. In these cases, the text is used to capture the full meaning of the source." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="CodeableConcept.text" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.9. But note many systems use C*E.2 for this" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./originalText[mediaType/code="text/plain"]/data" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.text rdfs:subPropertyOf dt:CD.originalText" /> - </mapping> - </element> - <element id="Condition.bodySite"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.bodySite" /> - <short value="Anatomical location, if relevant" /> - <definition value="The anatomical location where this condition manifests itself." /> - <comment value="Only used if not implicit in code found in Condition.code. If the use case requires attributes from the BodySite resource (e.g. to identify and track separately) then use the standard extension [bodySite](extension-bodysite.html). May be a summary code, or a reference to a very precise definition of the location, or both." /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Condition.bodySite" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="CodeableConcept" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <binding> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> - <valueString value="BodySite" /> - </extension> - <strength value="example" /> - <description value="Codes describing anatomical locations. May include laterality." /> - <valueSet value="http://hl7.org/fhir/ValueSet/body-site" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> - </mapping> - <mapping> - <identity value="sct-concept" /> - <map value="< 442083009 |Anatomical or acquired body structure|" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".targetBodySiteCode" /> - </mapping> - <mapping> - <identity value="sct-attr" /> - <map value="363698007" /> - </mapping> - </element> - <element id="Condition.bodySite.id"> - <path value="Condition.bodySite.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.bodySite.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.bodySite.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.bodySite.coding"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.bodySite.coding" /> - <slicing> - <discriminator> - <type value="pattern" /> - <path value="system" /> - </discriminator> - <rules value="open" /> - </slicing> - <short value="Code defined by a terminology system" /> - <definition value="A reference to a code defined by a terminology system." /> - <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> - <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> - <min value="1" /> - <max value="*" /> - <base> - <path value="CodeableConcept.coding" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Coding" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1-8, C*E.10-22" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="union(., ./translation)" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> - </mapping> - </element> - <element id="Condition.bodySite.coding:snomed-ct"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.bodySite.coding" /> - <sliceName value="snomed-ct" /> - <short value="Code defined by a terminology system" /> - <definition value="A reference to a code defined by a terminology system." /> - <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> - <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="CodeableConcept.coding" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Coding" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1-8, C*E.10-22" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="union(., ./translation)" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> - </mapping> - </element> - <element id="Condition.bodySite.coding:snomed-ct.id"> - <path value="Condition.bodySite.coding.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.bodySite.coding:snomed-ct.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.bodySite.coding.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.bodySite.coding:snomed-ct.system"> - <path value="Condition.bodySite.coding.system" /> - <short value="Identity of the terminology system" /> - <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> - <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> - <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.system" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="uri" /> - </type> - <patternUri value="http://snomed.info/sct" /> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.3" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystem" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> - </mapping> - </element> - <element id="Condition.bodySite.coding:snomed-ct.version"> - <path value="Condition.bodySite.coding.version" /> - <short value="Version of the system - if relevant" /> - <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> - <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.version" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.7" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./codeSystemVersion" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> - </mapping> - </element> - <element id="Condition.bodySite.coding:snomed-ct.code"> - <path value="Condition.bodySite.coding.code" /> - <short value="Symbol in syntax defined by the system" /> - <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to refer to a particular code in the system." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Coding.code" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="code" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.1" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./code" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> - </mapping> - </element> - <element id="Condition.bodySite.coding:snomed-ct.display"> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> - <valueBoolean value="true" /> - </extension> - <path value="Condition.bodySite.coding.display" /> - <short value="Representation defined by the system" /> - <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> - <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> - <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.display" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.2 - but note this is not well followed" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CV.displayName" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> - </mapping> - </element> - <element id="Condition.bodySite.coding:snomed-ct.userSelected"> - <path value="Condition.bodySite.coding.userSelected" /> - <short value="If this coding was chosen directly by the user" /> - <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> - <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> - <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Coding.userSelected" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="boolean" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="Sometimes implied by being first" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD.codingRationale" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> - </mapping> - </element> - <element id="Condition.bodySite.text"> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> - <valueBoolean value="true" /> - </extension> - <path value="Condition.bodySite.text" /> - <short value="Plain text representation of the concept" /> - <definition value="A human language representation of the concept as seen/selected/uttered by the user who entered the data and/or which represents the intended meaning of the user." /> - <comment value="Very often the text is the same as a displayName of one of the codings." /> - <requirements value="The codes from the terminologies do not always capture the correct meaning with all the nuances of the human using them, or sometimes there is no appropriate code at all. In these cases, the text is used to capture the full meaning of the source." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="CodeableConcept.text" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="C*E.9. But note many systems use C*E.2 for this" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./originalText[mediaType/code="text/plain"]/data" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept.text rdfs:subPropertyOf dt:CD.originalText" /> - </mapping> - </element> - <element id="Condition.subject"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.subject" /> - <short value="A reference from one resource to another" /> - <definition value="A reference from one resource to another." /> - <comment value="References SHALL be a reference to an actual FHIR resource, and SHALL be resolveable (allowing for access control, temporary unavailability, etc.). Resolution can be either by retrieval from the URL, or, where applicable by resource type, by treating an absolute reference as a canonical URL and looking it up in a local registry/repository." /> - <requirements value="Group is typically used for veterinary or public health use cases." /> - <alias value="patient" /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Condition.subject" /> - <min value="1" /> - <max value="1" /> - </base> - <type> - <code value="Reference" /> - <profile value="https://www.medizininformatik-initiative.de/fhir/core/StructureDefinition/MII-Reference" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/Patient" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/Group" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ref-1" /> - <severity value="error" /> - <human value="SHALL have a contained resource if a local reference is provided" /> - <expression value="reference.startsWith('#').not() or (reference.substring(1).trace('url') in %rootResource.contained.id.trace('ids'))" /> - <xpath value="not(starts-with(f:reference/@value, '#')) or exists(ancestor::*[self::f:entry or self::f:parameter]/f:resource/f:*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')]|/*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> - </constraint> - <constraint> - <key value="mii-reference-1" /> - <severity value="error" /> - <human value="Either reference.reference XOR reference.identifier exists" /> - <expression value="$this.reference.exists() xor ($this.identifier.value.exists() and $this.identifier.system.exists()) xor $this.extension('http://hl7.org/fhir/StructureDefinition/data-absent-reason').exists()" /> - <source value="https://www.medizininformatik-initiative.de/fhir/core/StructureDefinition/MII-Reference" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="The target of a resource reference is a RIM entry point (Act, Role, or Entity)" /> - </mapping> - <mapping> - <identity value="workflow" /> - <map value="Event.subject" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.subject[x]" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="PID-3" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".participation[typeCode=SBJ].role[classCode=PAT]" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.subject" /> - </mapping> - </element> - <element id="Condition.encounter"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.encounter" /> - <short value="Encounter created as part of" /> - <definition value="The Encounter during which this Condition was created or to which the creation of this record is tightly associated." /> - <comment value="This will typically be the encounter the event occurred within, but some activities may be initiated prior to or after the official completion of an encounter but still be tied to the context of the encounter. This record indicates the encounter this particular record is associated with. In the case of a "new" diagnosis reflecting ongoing/revised information about the condition, this might be distinct from the first encounter in which the underlying condition was first "known"." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Condition.encounter" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="Reference" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/Encounter" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ref-1" /> - <severity value="error" /> - <human value="SHALL have a contained resource if a local reference is provided" /> - <expression value="reference.startsWith('#').not() or (reference.substring(1).trace('url') in %rootResource.contained.id.trace('ids'))" /> - <xpath value="not(starts-with(f:reference/@value, '#')) or exists(ancestor::*[self::f:entry or self::f:parameter]/f:resource/f:*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')]|/*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="The target of a resource reference is a RIM entry point (Act, Role, or Entity)" /> - </mapping> - <mapping> - <identity value="workflow" /> - <map value="Event.context" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.context" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="PV1-19 (+PV1-54)" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN]" /> - </mapping> - </element> - <element id="Condition.onset[x]"> - <path value="Condition.onset[x]" /> - <slicing> - <discriminator> - <type value="type" /> - <path value="$this" /> - </discriminator> - <rules value="closed" /> - </slicing> - <short value="Estimated or actual date, date-time, or age" /> - <definition value="Estimated or actual date or date-time the condition began, in the opinion of the clinician." /> - <comment value="Age is generally used when the patient reports an age at which the Condition began to occur." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Condition.onset[x]" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="dateTime" /> - </type> - <type> - <code value="Period" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="workflow" /> - <map value="Event.occurrence[x]" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.init" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="PRB-16" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".effectiveTime.low or .inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="age at onset"].value" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetPeriod"> - <path value="Condition.onset[x]" /> - <sliceName value="onsetPeriod" /> - <short value="Estimated or actual date, date-time, or age" /> - <definition value="Estimated or actual date or date-time the condition began, in the opinion of the clinician." /> - <comment value="Age is generally used when the patient reports an age at which the Condition began to occur." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Condition.onset[x]" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="Period" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="workflow" /> - <map value="Event.occurrence[x]" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.init" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="PRB-16" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".effectiveTime.low or .inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="age at onset"].value" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetPeriod.id"> - <path value="Condition.onset[x].id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetPeriod.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.onset[x].extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetPeriod.extension:dataAbsentReason"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.onset[x].extension" /> - <sliceName value="dataAbsentReason" /> - <short value="unknown | asked | temp | notasked | masked | unsupported | astext | error" /> - <definition value="Provides a reason why the expected value or elements in the element that is extended are missing." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - <profile value="http://hl7.org/fhir/StructureDefinition/data-absent-reason" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="ANY.nullFlavor" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetPeriod.start"> - <path value="Condition.onset[x].start" /> - <short value="Starting time with inclusive boundary" /> - <definition value="The start of the period. The boundary is inclusive." /> - <comment value="If the low element is missing, the meaning is that the low boundary is not known." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Period.start" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="dateTime" /> - </type> - <condition value="ele-1" /> - <condition value="per-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="DR.1" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./low" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetPeriod.start.id"> - <path value="Condition.onset[x].start.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetPeriod.start.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.onset[x].start.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetPeriod.start.extension:lebensphase-von"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.onset[x].start.extension" /> - <sliceName value="lebensphase-von" /> - <short value="Optional Extensions Element" /> - <definition value="Optional Extension Element - found in all resources." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - <profile value="https://fhir.kbv.de/StructureDefinition/KBV_EX_Base_Stage_Life" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mustSupport value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetPeriod.start.value"> - <path value="Condition.onset[x].start.value" /> - <representation value="xmlAttr" /> - <short value="Primitive value for dateTime" /> - <definition value="Primitive value for dateTime" /> - <min value="0" /> - <max value="1" /> - <base> - <path value="dateTime.value" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="dateTime" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/regex"> - <valueString value="([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?" /> - </extension> - <code value="http://hl7.org/fhirpath/System.DateTime" /> - </type> - </element> - <element id="Condition.onset[x]:onsetPeriod.end"> - <path value="Condition.onset[x].end" /> - <short value="End time with inclusive boundary, if not ongoing" /> - <definition value="The end of the period. If the end of the period is missing, it means no end was known or planned at the time the instance was created. The start may be in the past, and the end date in the future, which means that period is expected/planned to end at that time." /> - <comment value="The high value includes any matching date/time. i.e. 2012-02-03T10:00:00 is in a period that has an end value of 2012-02-03." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Period.end" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="dateTime" /> - </type> - <meaningWhenMissing value="If the end of the period is missing, it means that the period is ongoing" /> - <condition value="ele-1" /> - <condition value="per-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="DR.2" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./high" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetPeriod.end.id"> - <path value="Condition.onset[x].end.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetPeriod.end.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.onset[x].end.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetPeriod.end.extension:lebensphase-bis"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.onset[x].end.extension" /> - <sliceName value="lebensphase-bis" /> - <short value="Optional Extensions Element" /> - <definition value="Optional Extension Element - found in all resources." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - <profile value="https://fhir.kbv.de/StructureDefinition/KBV_EX_Base_Stage_Life" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mustSupport value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetPeriod.end.value"> - <path value="Condition.onset[x].end.value" /> - <representation value="xmlAttr" /> - <short value="Primitive value for dateTime" /> - <definition value="Primitive value for dateTime" /> - <min value="0" /> - <max value="1" /> - <base> - <path value="dateTime.value" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="dateTime" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/regex"> - <valueString value="([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?" /> - </extension> - <code value="http://hl7.org/fhirpath/System.DateTime" /> - </type> - </element> - <element id="Condition.onset[x]:onsetDateTime"> - <path value="Condition.onset[x]" /> - <sliceName value="onsetDateTime" /> - <short value="Estimated or actual date, date-time, or age" /> - <definition value="Estimated or actual date or date-time the condition began, in the opinion of the clinician." /> - <comment value="Age is generally used when the patient reports an age at which the Condition began to occur." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Condition.onset[x]" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="dateTime" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="workflow" /> - <map value="Event.occurrence[x]" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.init" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="PRB-16" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".effectiveTime.low or .inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="age at onset"].value" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetDateTime.id"> - <path value="Condition.onset[x].id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetDateTime.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.onset[x].extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetDateTime.extension:dataAbsentReason"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.onset[x].extension" /> - <sliceName value="dataAbsentReason" /> - <short value="unknown | asked | temp | notasked | masked | unsupported | astext | error" /> - <definition value="Provides a reason why the expected value or elements in the element that is extended are missing." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - <profile value="http://hl7.org/fhir/StructureDefinition/data-absent-reason" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="ANY.nullFlavor" /> - </mapping> - </element> - <element id="Condition.onset[x]:onsetDateTime.value"> - <path value="Condition.onset[x].value" /> - <representation value="xmlAttr" /> - <short value="Primitive value for dateTime" /> - <definition value="Primitive value for dateTime" /> - <min value="0" /> - <max value="1" /> - <base> - <path value="dateTime.value" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="dateTime" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/regex"> - <valueString value="([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?" /> - </extension> - <code value="http://hl7.org/fhirpath/System.DateTime" /> - </type> - </element> - <element id="Condition.abatement[x]"> - <path value="Condition.abatement[x]" /> - <short value="When in resolution/remission" /> - <definition value="The date or estimated date that the condition resolved or went into remission. This is called "abatement" because of the many overloaded connotations associated with "remission" or "resolution" - Conditions are never really resolved, but they can abate." /> - <comment value="There is no explicit distinction between resolution and remission because in many cases the distinction is not clear. Age is generally used when the patient reports an age at which the Condition abated. If there is no abatement element, it is unknown whether the condition has resolved or entered remission; applications and users should generally assume that the condition is still valid. When abatementString exists, it implies the condition is abated." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Condition.abatement[x]" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="dateTime" /> - </type> - <type> - <code value="Age" /> - </type> - <type> - <code value="Period" /> - </type> - <type> - <code value="Range" /> - </type> - <type> - <code value="string" /> - </type> - <condition value="ele-1" /> - <condition value="con-4" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.done[x]" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".effectiveTime.high or .inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="age at remission"].value or .inboundRelationship[typeCode=SUBJ]source[classCode=CONC, moodCode=EVN].status=completed" /> - </mapping> - </element> - <element id="Condition.recordedDate"> - <path value="Condition.recordedDate" /> - <short value="Date record was first recorded" /> - <definition value="The recordedDate represents when this particular Condition record was created in the system, which is often a system-generated date." /> - <min value="1" /> - <max value="1" /> - <base> - <path value="Condition.recordedDate" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="dateTime" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.recorded" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="REL-11" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".participation[typeCode=AUT].time" /> - </mapping> - </element> - <element id="Condition.recorder"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.recorder" /> - <short value="Who recorded the condition" /> - <definition value="Individual who recorded the record and takes responsibility for its content." /> - <comment value="References SHALL be a reference to an actual FHIR resource, and SHALL be resolveable (allowing for access control, temporary unavailability, etc.). Resolution can be either by retrieval from the URL, or, where applicable by resource type, by treating an absolute reference as a canonical URL and looking it up in a local registry/repository." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Condition.recorder" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="Reference" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/Practitioner" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/PractitionerRole" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/Patient" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/RelatedPerson" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ref-1" /> - <severity value="error" /> - <human value="SHALL have a contained resource if a local reference is provided" /> - <expression value="reference.startsWith('#').not() or (reference.substring(1).trace('url') in %rootResource.contained.id.trace('ids'))" /> - <xpath value="not(starts-with(f:reference/@value, '#')) or exists(ancestor::*[self::f:entry or self::f:parameter]/f:resource/f:*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')]|/*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="The target of a resource reference is a RIM entry point (Act, Role, or Entity)" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.author" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".participation[typeCode=AUT].role" /> - </mapping> - </element> - <element id="Condition.asserter"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.asserter" /> - <short value="Person who asserts this condition" /> - <definition value="Individual who is making the condition statement." /> - <comment value="References SHALL be a reference to an actual FHIR resource, and SHALL be resolveable (allowing for access control, temporary unavailability, etc.). Resolution can be either by retrieval from the URL, or, where applicable by resource type, by treating an absolute reference as a canonical URL and looking it up in a local registry/repository." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Condition.asserter" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="Reference" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/Practitioner" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/PractitionerRole" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/Patient" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/RelatedPerson" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ref-1" /> - <severity value="error" /> - <human value="SHALL have a contained resource if a local reference is provided" /> - <expression value="reference.startsWith('#').not() or (reference.substring(1).trace('url') in %rootResource.contained.id.trace('ids'))" /> - <xpath value="not(starts-with(f:reference/@value, '#')) or exists(ancestor::*[self::f:entry or self::f:parameter]/f:resource/f:*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')]|/*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="The target of a resource reference is a RIM entry point (Act, Role, or Entity)" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.source" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="REL-7.1 identifier + REL-7.12 type code" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".participation[typeCode=INF].role" /> - </mapping> - </element> - <element id="Condition.stage"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.stage" /> - <short value="Stage/grade, usually assessed formally" /> - <definition value="Clinical stage or grade of a condition. May include formal severity assessments." /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Condition.stage" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="BackboneElement" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="con-1" /> - <severity value="error" /> - <human value="Stage SHALL have summary or assessment" /> - <expression value="summary.exists() or assessment.exists()" /> - <xpath value="exists(f:summary) or exists(f:assessment)" /> - <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="stage/grade"]" /> - </mapping> - </element> - <element id="Condition.stage.id"> - <path value="Condition.stage.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.stage.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.stage.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.stage.modifierExtension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.stage.modifierExtension" /> - <short value="Extensions that cannot be ignored even if unrecognized" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions. Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself)." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <requirements value="Modifier extensions allow for extensions that *cannot* be safely ignored to be clearly distinguished from the vast majority of extensions which can be safely ignored. This promotes interoperability by eliminating the need for implementers to prohibit the presence of extensions. For further information, see the [definition of modifier extensions](extensibility.html#modifierExtension)." /> - <alias value="extensions" /> - <alias value="user content" /> - <alias value="modifiers" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="BackboneElement.modifierExtension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <isModifier value="true" /> - <isModifierReason value="Modifier extensions are expected to modify the meaning or interpretation of the element that contains them" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.stage.summary"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.stage.summary" /> - <short value="Simple summary (disease specific)" /> - <definition value="A simple summary of the stage such as "Stage 3". The determination of the stage is disease-specific." /> - <comment value="Not all terminology uses fit this general pattern. In some cases, models should not use CodeableConcept and use Coding directly and provide their own structure for managing text, codings, translations and the relationship between elements and pre- and post-coordination." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Condition.stage.summary" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="CodeableConcept" /> - </type> - <condition value="ele-1" /> - <condition value="con-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <binding> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> - <valueString value="ConditionStage" /> - </extension> - <strength value="example" /> - <description value="Codes describing condition stages (e.g. Cancer stages)." /> - <valueSet value="http://hl7.org/fhir/ValueSet/condition-stage" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> - </mapping> - <mapping> - <identity value="sct-concept" /> - <map value="< 254291000 |Staging and scales|" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="PRB-14" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".value" /> - </mapping> - </element> - <element id="Condition.stage.assessment"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.stage.assessment" /> - <short value="Formal record of assessment" /> - <definition value="Reference to a formal record of the evidence on which the staging assessment is based." /> - <comment value="References SHALL be a reference to an actual FHIR resource, and SHALL be resolveable (allowing for access control, temporary unavailability, etc.). Resolution can be either by retrieval from the URL, or, where applicable by resource type, by treating an absolute reference as a canonical URL and looking it up in a local registry/repository." /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Condition.stage.assessment" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Reference" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/ClinicalImpression" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/DiagnosticReport" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/Observation" /> - </type> - <condition value="ele-1" /> - <condition value="con-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ref-1" /> - <severity value="error" /> - <human value="SHALL have a contained resource if a local reference is provided" /> - <expression value="reference.startsWith('#').not() or (reference.substring(1).trace('url') in %rootResource.contained.id.trace('ids'))" /> - <xpath value="not(starts-with(f:reference/@value, '#')) or exists(ancestor::*[self::f:entry or self::f:parameter]/f:resource/f:*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')]|/*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="The target of a resource reference is a RIM entry point (Act, Role, or Entity)" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".self" /> - </mapping> - </element> - <element id="Condition.stage.type"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.stage.type" /> - <short value="Kind of staging" /> - <definition value="The kind of staging, such as pathological or clinical staging." /> - <comment value="Not all terminology uses fit this general pattern. In some cases, models should not use CodeableConcept and use Coding directly and provide their own structure for managing text, codings, translations and the relationship between elements and pre- and post-coordination." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Condition.stage.type" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <code value="CodeableConcept" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <binding> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> - <valueString value="ConditionStageType" /> - </extension> - <strength value="example" /> - <description value="Codes describing the kind of condition staging (e.g. clinical or pathological)." /> - <valueSet value="http://hl7.org/fhir/ValueSet/condition-stage-type" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="./inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="stage type"]" /> - </mapping> - </element> - <element id="Condition.evidence"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.evidence" /> - <short value="Supporting evidence" /> - <definition value="Supporting evidence / manifestations that are the basis of the Condition's verification status, such as evidence that confirmed or refuted the condition." /> - <comment value="The evidence may be a simple list of coded symptoms/manifestations, or references to observations or formal assessments, or both." /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Condition.evidence" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="BackboneElement" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="con-2" /> - <severity value="error" /> - <human value="evidence SHALL have code or details" /> - <expression value="code.exists() or detail.exists()" /> - <xpath value="exists(f:code) or exists(f:detail)" /> - <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".outboundRelationship[typeCode=SPRT].target[classCode=OBS, moodCode=EVN]" /> - </mapping> - </element> - <element id="Condition.evidence.id"> - <path value="Condition.evidence.id" /> - <representation value="xmlAttr" /> - <short value="Unique id for inter-element referencing" /> - <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> - <min value="0" /> - <max value="1" /> - <base> - <path value="Element.id" /> - <min value="0" /> - <max value="1" /> - </base> - <type> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> - <valueUrl value="string" /> - </extension> - <code value="http://hl7.org/fhirpath/System.String" /> - </type> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - </element> - <element id="Condition.evidence.extension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.evidence.extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <description value="Extensions are always sliced by (at least) url" /> - <rules value="open" /> - </slicing> - <short value="Additional content defined by implementations" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <alias value="extensions" /> - <alias value="user content" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Element.extension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.evidence.modifierExtension"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.evidence.modifierExtension" /> - <short value="Extensions that cannot be ignored even if unrecognized" /> - <definition value="May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions. Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself)." /> - <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> - <requirements value="Modifier extensions allow for extensions that *cannot* be safely ignored to be clearly distinguished from the vast majority of extensions which can be safely ignored. This promotes interoperability by eliminating the need for implementers to prohibit the presence of extensions. For further information, see the [definition of modifier extensions](extensibility.html#modifierExtension)." /> - <alias value="extensions" /> - <alias value="user content" /> - <alias value="modifiers" /> - <min value="0" /> - <max value="*" /> - <base> - <path value="BackboneElement.modifierExtension" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Extension" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ext-1" /> - <severity value="error" /> - <human value="Must have either extensions or value[x], not both" /> - <expression value="extension.exists() != value.exists()" /> - <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> - </constraint> - <isModifier value="true" /> - <isModifierReason value="Modifier extensions are expected to modify the meaning or interpretation of the element that contains them" /> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="N/A" /> - </mapping> - </element> - <element id="Condition.evidence.code"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.evidence.code" /> - <short value="Manifestation/symptom" /> - <definition value="A manifestation or symptom that led to the recording of this condition." /> - <comment value="Not all terminology uses fit this general pattern. In some cases, models should not use CodeableConcept and use Coding directly and provide their own structure for managing text, codings, translations and the relationship between elements and pre- and post-coordination." /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Condition.evidence.code" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="CodeableConcept" /> - </type> - <condition value="ele-1" /> - <condition value="con-2" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <isSummary value="true" /> - <binding> - <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> - <valueString value="ManifestationOrSymptom" /> - </extension> - <strength value="example" /> - <description value="Codes that describe the manifestation or symptoms of a condition." /> - <valueSet value="http://hl7.org/fhir/ValueSet/manifestation-or-symptom" /> - </binding> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="CE/CNE/CWE" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="CD" /> - </mapping> - <mapping> - <identity value="orim" /> - <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> - </mapping> - <mapping> - <identity value="workflow" /> - <map value="Event.reasonCode" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.why[x]" /> - </mapping> - <mapping> - <identity value="sct-concept" /> - <map value="< 404684003 |Clinical finding|" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="[code="diagnosis"].value" /> - </mapping> - </element> - <element id="Condition.evidence.detail"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.evidence.detail" /> - <short value="Supporting information found elsewhere" /> - <definition value="Links to other relevant information, including pathology reports." /> - <comment value="References SHALL be a reference to an actual FHIR resource, and SHALL be resolveable (allowing for access control, temporary unavailability, etc.). Resolution can be either by retrieval from the URL, or, where applicable by resource type, by treating an absolute reference as a canonical URL and looking it up in a local registry/repository." /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Condition.evidence.detail" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Reference" /> - <targetProfile value="http://hl7.org/fhir/StructureDefinition/Resource" /> - </type> - <condition value="ele-1" /> - <condition value="con-2" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <constraint> - <key value="ref-1" /> - <severity value="error" /> - <human value="SHALL have a contained resource if a local reference is provided" /> - <expression value="reference.startsWith('#').not() or (reference.substring(1).trace('url') in %rootResource.contained.id.trace('ids'))" /> - <xpath value="not(starts-with(f:reference/@value, '#')) or exists(ancestor::*[self::f:entry or self::f:parameter]/f:resource/f:*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')]|/*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')])" /> - <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> - </constraint> - <isSummary value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="The target of a resource reference is a RIM entry point (Act, Role, or Entity)" /> - </mapping> - <mapping> - <identity value="w5" /> - <map value="FiveWs.why[x]" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".self" /> - </mapping> - </element> - <element id="Condition.note"> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> - <valueCode value="normative" /> - </extension> - <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> - <valueCode value="4.0.0" /> - </extension> - <path value="Condition.note" /> - <short value="Additional information about the Condition" /> - <definition value="Additional information about the Condition. This is a general notes/comments entry for description of the Condition, its diagnosis and prognosis." /> - <comment value="For systems that do not have structured annotations, they can simply communicate a single annotation with no author or time. This element may need to be included in narrative because of the potential for modifying information. *Annotations SHOULD NOT* be used to communicate "modifying" information that could be computable. (This is a SHOULD because enforcing user behavior is nearly impossible)." /> - <min value="0" /> - <max value="*" /> - <base> - <path value="Condition.note" /> - <min value="0" /> - <max value="*" /> - </base> - <type> - <code value="Annotation" /> - </type> - <condition value="ele-1" /> - <constraint> - <key value="ele-1" /> - <severity value="error" /> - <human value="All FHIR elements must have a @value or children" /> - <expression value="hasValue() or (children().count() > id.count())" /> - <xpath value="@value|f:*|h:div" /> - <source value="http://hl7.org/fhir/StructureDefinition/Element" /> - </constraint> - <mustSupport value="true" /> - <mapping> - <identity value="rim" /> - <map value="n/a" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="N/A" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value="Act" /> - </mapping> - <mapping> - <identity value="workflow" /> - <map value="Event.note" /> - </mapping> - <mapping> - <identity value="v2" /> - <map value="NTE child of PRB" /> - </mapping> - <mapping> - <identity value="rim" /> - <map value=".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="annotation"].value" /> - </mapping> - </element> - </snapshot> - <differential> - <element id="Condition.category"> - <path value="Condition.category" /> - <min value="1" /> - <mustSupport value="true" /> - </element> - <element id="Condition.category.coding"> - <path value="Condition.category.coding" /> - <slicing> - <discriminator> - <type value="pattern" /> - <path value="$this" /> - </discriminator> - <rules value="open" /> - </slicing> - <min value="1" /> - <mustSupport value="true" /> - </element> - <element id="Condition.category.coding:symptoms"> - <path value="Condition.category.coding" /> - <sliceName value="symptoms" /> - <min value="1" /> - <max value="1" /> - <patternCoding> - <system value="http://loinc.org" /> - <code value="75325-1" /> - </patternCoding> - <mustSupport value="true" /> - </element> - <element id="Condition.category.coding:symptoms.system"> - <path value="Condition.category.coding.system" /> - <min value="1" /> - <mustSupport value="true" /> - </element> - <element id="Condition.category.coding:symptoms.code"> - <path value="Condition.category.coding.code" /> - <min value="1" /> - <mustSupport value="true" /> - </element> - <element id="Condition.severity"> - <path value="Condition.severity" /> - <mustSupport value="true" /> - <binding> - <strength value="preferred" /> - <valueSet value="https://www.netzwerk-universitaetsmedizin.de/fhir/ValueSet/condition-severity" /> - </binding> - </element> - <element id="Condition.code.coding:sct"> - <path value="Condition.code.coding" /> - <sliceName value="sct" /> - <min value="1" /> - <binding> - <strength value="required" /> - <valueSet value="https://www.netzwerk-universitaetsmedizin.de/fhir/ValueSet/sars-cov-2-symptoms" /> - </binding> - </element> - <element id="Condition.code.coding:orphanet"> - <path value="Condition.code.coding" /> - <sliceName value="orphanet" /> - <max value="0" /> - </element> - <element id="Condition.onset[x]:onsetPeriod"> - <path value="Condition.onset[x]" /> - <sliceName value="onsetPeriod" /> - </element> - <element id="Condition.onset[x]:onsetPeriod.extension"> - <path value="Condition.onset[x].extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <rules value="open" /> - </slicing> - </element> - <element id="Condition.onset[x]:onsetPeriod.extension:dataAbsentReason"> - <path value="Condition.onset[x].extension" /> - <sliceName value="dataAbsentReason" /> - <type> - <code value="Extension" /> - <profile value="http://hl7.org/fhir/StructureDefinition/data-absent-reason" /> - </type> - </element> - <element id="Condition.onset[x]:onsetDateTime"> - <path value="Condition.onset[x]" /> - <sliceName value="onsetDateTime" /> - </element> - <element id="Condition.onset[x]:onsetDateTime.extension"> - <path value="Condition.onset[x].extension" /> - <slicing> - <discriminator> - <type value="value" /> - <path value="url" /> - </discriminator> - <rules value="open" /> - </slicing> - </element> - <element id="Condition.onset[x]:onsetDateTime.extension:dataAbsentReason"> - <path value="Condition.onset[x].extension" /> - <sliceName value="dataAbsentReason" /> - <type> - <code value="Extension" /> - <profile value="http://hl7.org/fhir/StructureDefinition/data-absent-reason" /> - </type> - </element> - </differential> +<StructureDefinition xmlns="http://hl7.org/fhir"> + <id value="gecco-condition-symptoms-covid-19" /> + <url value="https://www.netzwerk-universitaetsmedizin.de/fhir/StructureDefinition/symptoms-covid-19" /> + <version value="1.0" /> + <name value="SymptomsCovid19" /> + <title value="Symptoms Covid-19" /> + <status value="active" /> + <date value="2020-10-29" /> + <publisher value="Charité" /> + <contact> + <telecom> + <system value="url" /> + <value value="https://www.bihealth.org/en/research/core-facilities/interoperability/" /> + </telecom> + </contact> + <description value="Symptoms of Covid-19" /> + <fhirVersion value="4.0.1" /> + <mapping> + <identity value="workflow" /> + <uri value="http://hl7.org/fhir/workflow" /> + <name value="Workflow Pattern" /> + </mapping> + <mapping> + <identity value="sct-concept" /> + <uri value="http://snomed.info/conceptdomain" /> + <name value="SNOMED CT Concept Domain Binding" /> + </mapping> + <mapping> + <identity value="v2" /> + <uri value="http://hl7.org/v2" /> + <name value="HL7 v2 Mapping" /> + </mapping> + <mapping> + <identity value="rim" /> + <uri value="http://hl7.org/v3" /> + <name value="RIM Mapping" /> + </mapping> + <mapping> + <identity value="w5" /> + <uri value="http://hl7.org/fhir/fivews" /> + <name value="FiveWs Pattern Mapping" /> + </mapping> + <mapping> + <identity value="sct-attr" /> + <uri value="http://snomed.org/attributebinding" /> + <name value="SNOMED CT Attribute Binding" /> + </mapping> + <kind value="resource" /> + <abstract value="false" /> + <type value="Condition" /> + <baseDefinition value="https://www.netzwerk-universitaetsmedizin.de/fhir/StructureDefinition/gecco-base-condition" /> + <derivation value="constraint" /> + <snapshot> + <element id="Condition"> + <path value="Condition" /> + <short value="Detailed information about conditions, problems or diagnoses" /> + <definition value="A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern." /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Condition" /> + <min value="0" /> + <max value="*" /> + </base> + <constraint> + <key value="dom-2" /> + <severity value="error" /> + <human value="If the resource is contained in another resource, it SHALL NOT contain nested Resources" /> + <expression value="contained.contained.empty()" /> + <xpath value="not(parent::f:contained and f:contained)" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <constraint> + <key value="dom-4" /> + <severity value="error" /> + <human value="If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated" /> + <expression value="contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()" /> + <xpath value="not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <constraint> + <key value="dom-3" /> + <severity value="error" /> + <human value="If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource or SHALL refer to the containing resource" /> + <expression value="contained.where((('#'+id in (%resource.descendants().reference | %resource.descendants().as(canonical) | %resource.descendants().as(uri) | %resource.descendants().as(url))) or descendants().where(reference = '#').exists() or descendants().where(as(canonical) = '#').exists() or descendants().where(as(canonical) = '#').exists()).not()).trace('unmatched', id).empty()" /> + <xpath value="not(exists(for $id in f:contained/*/f:id/@value return $contained[not(parent::*/descendant::f:reference/@value=concat('#', $contained/*/id/@value) or descendant::f:reference[@value='#'])]))" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <constraint> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bestpractice"> + <valueBoolean value="true" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bestpractice-explanation"> + <valueMarkdown value="When a resource has no narrative, only systems that fully understand the data can display the resource to a human safely. Including a human readable representation in the resource makes for a much more robust eco-system and cheaper handling of resources by intermediary systems. Some ecosystems restrict distribution of resources to only those systems that do fully understand the resources, and as a consequence implementers may believe that the narrative is superfluous. However experience shows that such eco-systems often open up to new participants over time." /> + </extension> + <key value="dom-6" /> + <severity value="warning" /> + <human value="A resource should have narrative for robust management" /> + <expression value="text.`div`.exists()" /> + <xpath value="exists(f:text/h:div)" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <constraint> + <key value="dom-5" /> + <severity value="error" /> + <human value="If a resource is contained in another resource, it SHALL NOT have a security label" /> + <expression value="contained.meta.security.empty()" /> + <xpath value="not(exists(f:contained/*/f:meta/f:security))" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <constraint> + <key value="con-5" /> + <severity value="error" /> + <human value="Condition.clinicalStatus SHALL NOT be present if verification Status is entered-in-error" /> + <expression value="verificationStatus.coding.where(system='http://terminology.hl7.org/CodeSystem/condition-ver-status' and code='entered-in-error').empty() or clinicalStatus.empty()" /> + <xpath value="not(exists(f:verificationStatus/f:coding[f:system/@value='http://terminology.hl7.org/CodeSystem/condition-ver-status' and f:code/@value='entered-in-error'])) or not(exists(f:clinicalStatus))" /> + <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> + </constraint> + <constraint> + <key value="con-4" /> + <severity value="error" /> + <human value="If condition is abated, then clinicalStatus must be either inactive, resolved, or remission" /> + <expression value="abatement.empty() or clinicalStatus.coding.where(system='http://terminology.hl7.org/CodeSystem/condition-clinical' and (code='resolved' or code='remission' or code='inactive')).exists()" /> + <xpath value="not(exists(*[starts-with(local-name(.), 'abatement')])) or exists(f:clinicalStatus/f:coding[f:system/@value='http://terminology.hl7.org/CodeSystem/condition-clinical' and f:code/@value=('resolved', 'remission', 'inactive')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> + </constraint> + <constraint> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bestpractice"> + <valueBoolean value="true" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bestpractice-explanation"> + <valueMarkdown value="Most systems will expect a clinicalStatus to be valued for problem-list-items that are managed over time, but might not need a clinicalStatus for point in time encounter-diagnosis." /> + </extension> + <key value="con-3" /> + <severity value="warning" /> + <human value="Condition.clinicalStatus SHALL be present if verificationStatus is not entered-in-error and category is problem-list-item" /> + <expression value="clinicalStatus.exists() or verificationStatus.coding.where(system='http://terminology.hl7.org/CodeSystem/condition-ver-status' and code = 'entered-in-error').exists() or category.select($this='problem-list-item').empty()" /> + <xpath value="exists(f:clinicalStatus) or exists(f:verificationStatus/f:coding/f:code/@value='entered-in-error') or not(exists(category[@value='problem-list-item']))" /> + <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> + </constraint> + <constraint> + <key value="icd-1" /> + <severity value="warning" /> + <human value="Bei Angabe eines Codes in der Haupt-Kreuz-Extension, muss dieser auch Bestandteil des postkoordinierten ICD-Codes sein!" /> + <expression value="extension('https://www.medizininformatik-initiative.de/fhir/core/StructureDefinition/icd-10-gm-primaercode').empty() or code.contains($this.extension('https://www.medizininformatik-initiative.de/fhir/core/StructureDefinition/icd-10-gm-primaercode').value.code)" /> + <source value="https://www.medizininformatik-initiative.de/fhir/core/modul-diagnose/StructureDefinition/Diagnose" /> + </constraint> + <constraint> + <key value="icd-2" /> + <severity value="warning" /> + <human value="Bei Angabe eines Codes in der Stern-Extension, muss dieser auch Bestandteil des postkoordinierten ICD-Codes sein!" /> + <expression value="extension('https://www.medizininformatik-initiative.de/fhir/core/StructureDefinition/icd-10-gm-manifestation').empty() or code.contains($this.extension('https://www.medizininformatik-initiative.de/fhir/core/StructureDefinition/icd-10-gm-manifestation').value.code)" /> + <source value="https://www.medizininformatik-initiative.de/fhir/core/modul-diagnose/StructureDefinition/Diagnose" /> + </constraint> + <constraint> + <key value="icd-3" /> + <severity value="warning" /> + <human value="Bei Angabe eines Codes in der Ausrufezeichen-Extension, muss dieser auch Bestandteil des postkoordinierten ICD-Codes sein!" /> + <expression value="extension('http://fhir.de/StructureDefinition/icd-10-gm-ausrufezeichen').empty() or code.contains($this.extension('http://fhir.de/StructureDefinition/icd-10-gm-ausrufezeichen').value.code)" /> + <source value="https://www.medizininformatik-initiative.de/fhir/core/modul-diagnose/StructureDefinition/Diagnose" /> + </constraint> + <constraint> + <key value="icd-8" /> + <severity value="warning" /> + <human value="Bei Angabe eines Codes in der Seitenlokalisations-Extension, muss dieser auch Bestandteil des ICD-Codes sein!" /> + <expression value="extension('http://fhir.de/StructureDefinition/seitenlokalisation').empty() or code.contains($this.extension('http://fhir.de/StructureDefinition/seitenlokalisation').value.code)" /> + <source value="https://www.medizininformatik-initiative.de/fhir/core/modul-diagnose/StructureDefinition/Diagnose" /> + </constraint> + <constraint> + <key value="unk-1" /> + <severity value="error" /> + <human value="If verificationStatus is present, uncertaintyOfPresence-Extension SHALL NOT be present." /> + <expression value="verificationStatus.exists() != Condition.modifierExtension.where(url = 'https://www.netzwerk-universitaetsmedizin.de/fhir/StructureDefinition/uncertainty-of-presence').exists()" /> + <source value="https://www.netzwerk-universitaetsmedizin.de/fhir/StructureDefinition/gecco-base-condition" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="Entity. Role, or Act" /> + </mapping> + <mapping> + <identity value="workflow" /> + <map value="Event" /> + </mapping> + <mapping> + <identity value="sct-concept" /> + <map value="< 243796009 |Situation with explicit context| : 246090004 |Associated finding| = ( ( < 404684003 |Clinical finding| MINUS ( << 420134006 |Propensity to adverse reactions| OR << 473010000 |Hypersensitivity condition| OR << 79899007 |Drug interaction| OR << 69449002 |Drug action| OR << 441742003 |Evaluation finding| OR << 307824009 |Administrative status| OR << 385356007 |Tumor stage finding|)) OR < 272379006 |Event|)" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="PPR message" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="Observation[classCode=OBS, moodCode=EVN, code=ASSERTION, value<Diagnosis]" /> + </mapping> + </element> + <element id="Condition.id"> + <path value="Condition.id" /> + <short value="Logical id of this artifact" /> + <definition value="The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes." /> + <comment value="The only time that a resource does not have an id is when it is being submitted to the server using a create operation." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Resource.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mustSupport value="true" /> + <isSummary value="true" /> + </element> + <element id="Condition.meta"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.meta" /> + <short value="Metadata about the resource" /> + <definition value="The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Resource.meta" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="Meta" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.meta.id"> + <path value="Condition.meta.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.meta.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.meta.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.meta.versionId"> + <path value="Condition.meta.versionId" /> + <short value="Version specific identifier" /> + <definition value="The version specific identifier, as it appears in the version portion of the URL. This value changes when the resource is created, updated, or deleted." /> + <comment value="The server assigns this value, and ignores what the client specifies, except in the case that the server is imposing version integrity on updates/deletes." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Meta.versionId" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="id" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.meta.lastUpdated"> + <path value="Condition.meta.lastUpdated" /> + <short value="When the resource version last changed" /> + <definition value="When the resource last changed - e.g. when the version changed." /> + <comment value="This value is always populated except when the resource is first being created. The server / resource manager sets this value; what a client provides is irrelevant. This is equivalent to the HTTP Last-Modified and SHOULD have the same value on a [read](http.html#read) interaction." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Meta.lastUpdated" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="instant" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.meta.source"> + <path value="Condition.meta.source" /> + <short value="Identifies where the resource comes from" /> + <definition value="A uri that identifies the source system of the resource. This provides a minimal amount of [Provenance](provenance.html#) information that can be used to track or differentiate the source of information in the resource. The source may identify another FHIR server, document, message, database, etc." /> + <comment value="In the provenance resource, this corresponds to Provenance.entity.what[x]. The exact use of the source (and the implied Provenance.entity.role) is left to implementer discretion. Only one nominated source is allowed; for additional provenance details, a full Provenance resource should be used. This element can be used to indicate where the current master source of a resource that has a canonical URL if the resource is no longer hosted at the canonical URL." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Meta.source" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="uri" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.meta.profile"> + <path value="Condition.meta.profile" /> + <short value="Profiles this resource claims to conform to" /> + <definition value="A list of profiles (references to [StructureDefinition](structuredefinition.html#) resources) that this resource claims to conform to. The URL is a reference to [StructureDefinition.url](structuredefinition-definitions.html#StructureDefinition.url)." /> + <comment value="It is up to the server and/or other infrastructure of policy to determine whether/how these claims are verified and/or updated over time. The list of profile URLs is a set." /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Meta.profile" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="canonical" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/StructureDefinition" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.meta.security"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.meta.security" /> + <short value="Security Labels applied to this resource" /> + <definition value="Security labels applied to this resource. These tags connect specific resources to the overall security policy and infrastructure." /> + <comment value="The security labels can be updated without changing the stated version of the resource. The list of security labels is a set. Uniqueness is based the system/code, and version and display are ignored." /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Meta.security" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Coding" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <binding> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> + <valueString value="SecurityLabels" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding"> + <valueBoolean value="true" /> + </extension> + <strength value="extensible" /> + <description value="Security Labels from the Healthcare Privacy and Security Classification System." /> + <valueSet value="http://hl7.org/fhir/ValueSet/security-labels" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> + </mapping> + </element> + <element id="Condition.meta.tag"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.meta.tag" /> + <short value="Tags applied to this resource" /> + <definition value="Tags applied to this resource. Tags are intended to be used to identify and relate resources to process and workflow, and applications are not required to consider the tags when interpreting the meaning of a resource." /> + <comment value="The tags can be updated without changing the stated version of the resource. The list of tags is a set. Uniqueness is based the system/code, and version and display are ignored." /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Meta.tag" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Coding" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <binding> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> + <valueString value="Tags" /> + </extension> + <strength value="example" /> + <description value="Codes that represent various types of tags, commonly workflow-related; e.g. "Needs review by Dr. Jones"." /> + <valueSet value="http://hl7.org/fhir/ValueSet/common-tags" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> + </mapping> + </element> + <element id="Condition.implicitRules"> + <path value="Condition.implicitRules" /> + <short value="A set of rules under which this content was created" /> + <definition value="A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content. Often, this is a reference to an implementation guide that defines the special rules along with other profiles etc." /> + <comment value="Asserting this rule set restricts the content to be only understood by a limited set of trading partners. This inherently limits the usefulness of the data in the long term. However, the existing health eco-system is highly fractured, and not yet ready to define, collect, and exchange data in a generally computable sense. Wherever possible, implementers and/or specification writers should avoid using this element. Often, when used, the URL is a reference to an implementation guide that defines these special rules as part of it's narrative along with other profiles, value sets, etc." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Resource.implicitRules" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="uri" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isModifier value="true" /> + <isModifierReason value="This element is labeled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.language"> + <path value="Condition.language" /> + <short value="Language of the resource content" /> + <definition value="The base language in which the resource is written." /> + <comment value="Language is provided to support indexing and accessibility (typically, services such as text to speech use the language tag). The html language tag in the narrative applies to the narrative. The language tag on the resource may be used to specify the language of other presentations generated from the data in the resource. Not all the content has to be in the base language. The Resource.language should not be assumed to apply to the narrative automatically. If a language is specified, it should it also be specified on the div element in the html (see rules in HTML5 for information about the relationship between xml:lang and the html lang attribute)." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Resource.language" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="code" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <binding> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet"> + <valueCanonical value="http://hl7.org/fhir/ValueSet/all-languages" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> + <valueString value="Language" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding"> + <valueBoolean value="true" /> + </extension> + <strength value="preferred" /> + <description value="A human language." /> + <valueSet value="http://hl7.org/fhir/ValueSet/languages" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.text"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.text" /> + <short value="Text summary of the resource, for human interpretation" /> + <definition value="A human-readable narrative that contains a summary of the resource and can be used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it "clinically safe" for a human to just read the narrative. Resource definitions may define what content should be represented in the narrative to ensure clinical safety." /> + <comment value="Contained resources do not have narrative. Resources that are not contained SHOULD have a narrative. In some cases, a resource may only have text with little or no additional discrete data (as long as all minOccurs=1 elements are satisfied). This may be necessary for data from legacy systems where information is captured as a "text blob" or where text is additionally entered raw or narrated and encoded information is added later." /> + <alias value="narrative" /> + <alias value="html" /> + <alias value="xhtml" /> + <alias value="display" /> + <min value="0" /> + <max value="1" /> + <base> + <path value="DomainResource.text" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="Narrative" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="Act.text?" /> + </mapping> + </element> + <element id="Condition.contained"> + <path value="Condition.contained" /> + <short value="Contained, inline Resources" /> + <definition value="These resources do not have an independent existence apart from the resource that contains them - they cannot be identified independently, and nor can they have their own independent transaction scope." /> + <comment value="This should never be done when the content can be identified properly, as once identification is lost, it is extremely difficult (and context dependent) to restore it again. Contained resources may have profiles and tags In their meta elements, but SHALL NOT have security labels." /> + <alias value="inline resources" /> + <alias value="anonymous resources" /> + <alias value="contained resources" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="DomainResource.contained" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Resource" /> + </type> + <mapping> + <identity value="rim" /> + <map value="Entity. Role, or Act" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the resource. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="DomainResource.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.modifierExtension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.modifierExtension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Extensions that cannot be ignored" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the resource and that modifies the understanding of the element that contains it and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions. Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself)." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <requirements value="Modifier extensions allow for extensions that *cannot* be safely ignored to be clearly distinguished from the vast majority of extensions which can be safely ignored. This promotes interoperability by eliminating the need for implementers to prohibit the presence of extensions. For further information, see the [definition of modifier extensions](extensibility.html#modifierExtension)." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="DomainResource.modifierExtension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <isModifier value="true" /> + <isModifierReason value="Modifier extensions are expected to modify the meaning or interpretation of the resource that contains them" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.modifierExtension:uncertaintyOfPresence"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.modifierExtension" /> + <sliceName value="uncertaintyOfPresence" /> + <short value="Uncertainty of presence" /> + <definition value="Extension used on a condition resource if the presence of the condition is unknown." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <requirements value="Modifier extensions allow for extensions that *cannot* be safely ignored to be clearly distinguished from the vast majority of extensions which can be safely ignored. This promotes interoperability by eliminating the need for implementers to prohibit the presence of extensions. For further information, see the [definition of modifier extensions](extensibility.html#modifierExtension)." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="1" /> + <base> + <path value="DomainResource.modifierExtension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + <profile value="https://www.netzwerk-universitaetsmedizin.de/fhir/StructureDefinition/uncertainty-of-presence" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mustSupport value="true" /> + <isModifier value="true" /> + <isModifierReason value="Modifies the meaning of the presence of a condition to being unknown." /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.identifier"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.identifier" /> + <short value="External Ids for this condition" /> + <definition value="Business identifiers assigned to this condition by the performer or other systems which remain constant as the resource is updated and propagates from server to server." /> + <comment value="This is a business identifier, not a resource identifier (see [discussion](resource.html#identifiers)). It is best practice for the identifier to only appear on a single resource instance, however business practices may occasionally dictate that multiple resource instances with the same identifier can exist - possibly even with different resource types. For example, multiple Patient and a Person resource instance might share the same social insurance number." /> + <requirements value="Allows identification of the condition as it is known by various participating systems and in a way that remains consistent across servers." /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Condition.identifier" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Identifier" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CX / EI (occasionally, more often EI maps to a resource id or a URL)" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="II - The Identifier class is a little looser than the v3 type II because it allows URIs as well as registered OIDs or GUIDs. Also maps to Role[classCode=IDENT]" /> + </mapping> + <mapping> + <identity value="servd" /> + <map value="Identifier" /> + </mapping> + <mapping> + <identity value="workflow" /> + <map value="Event.identifier" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.identifier" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".id" /> + </mapping> + </element> + <element id="Condition.clinicalStatus"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.clinicalStatus" /> + <short value="active | recurrence | relapse | inactive | remission | resolved" /> + <definition value="The clinical status of the condition." /> + <comment value="The data type is CodeableConcept because clinicalStatus has some clinical judgment involved, such that there might need to be more specificity than the required FHIR value set allows. For example, a SNOMED coding might allow for additional specificity." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Condition.clinicalStatus" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="CodeableConcept" /> + </type> + <condition value="ele-1" /> + <condition value="con-3" /> + <condition value="con-4" /> + <condition value="con-5" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isModifier value="true" /> + <isModifierReason value="This element is labeled as a modifier because the status contains codes that mark the condition as no longer active." /> + <isSummary value="true" /> + <binding> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> + <valueString value="ConditionClinicalStatus" /> + </extension> + <strength value="required" /> + <description value="The clinical status of the condition or diagnosis." /> + <valueSet value="http://hl7.org/fhir/ValueSet/condition-clinical|4.0.1" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> + </mapping> + <mapping> + <identity value="workflow" /> + <map value="Event.status" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.status" /> + </mapping> + <mapping> + <identity value="sct-concept" /> + <map value="< 303105007 |Disease phases|" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="PRB-14" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="Observation ACT .inboundRelationship[typeCode=COMP].source[classCode=OBS, code="clinicalStatus", moodCode=EVN].value" /> + </mapping> + </element> + <element id="Condition.verificationStatus"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.verificationStatus" /> + <short value="unconfirmed | provisional | differential | confirmed | refuted | entered-in-error" /> + <definition value="The verification status to support the clinical status of the condition." /> + <comment value="verificationStatus is not required. For example, when a patient has abdominal pain in the ED, there is not likely going to be a verification status. The data type is CodeableConcept because verificationStatus has some clinical judgment involved, such that there might need to be more specificity than the required FHIR value set allows. For example, a SNOMED coding might allow for additional specificity." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Condition.verificationStatus" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="CodeableConcept" /> + </type> + <condition value="ele-1" /> + <condition value="con-3" /> + <condition value="con-5" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isModifier value="true" /> + <isModifierReason value="This element is labeled as a modifier because the status contains the code refuted and entered-in-error that mark the Condition as not currently valid." /> + <isSummary value="true" /> + <binding> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> + <valueString value="ConditionVerificationStatus" /> + </extension> + <strength value="required" /> + <description value="The verification status to support or decline the clinical status of the condition or diagnosis." /> + <valueSet value="http://hl7.org/fhir/ValueSet/condition-ver-status|4.0.1" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> + </mapping> + <mapping> + <identity value="workflow" /> + <map value="Event.status" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.status" /> + </mapping> + <mapping> + <identity value="sct-concept" /> + <map value="< 410514004 |Finding context value|" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="PRB-13" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="Observation ACT .inboundRelationship[typeCode=COMP].source[classCode=OBS, code="verificationStatus", moodCode=EVN].value" /> + </mapping> + <mapping> + <identity value="sct-attr" /> + <map value="408729009" /> + </mapping> + </element> + <element id="Condition.verificationStatus.id"> + <path value="Condition.verificationStatus.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.verificationStatus.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.verificationStatus.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.verificationStatus.coding" /> + <slicing> + <discriminator> + <type value="pattern" /> + <path value="$this" /> + </discriminator> + <rules value="open" /> + </slicing> + <short value="Code defined by a terminology system" /> + <definition value="A reference to a code defined by a terminology system." /> + <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> + <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> + <min value="1" /> + <max value="*" /> + <base> + <path value="CodeableConcept.coding" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Coding" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1-8, C*E.10-22" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="union(., ./translation)" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:conditionVerificationStatus"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.verificationStatus.coding" /> + <sliceName value="conditionVerificationStatus" /> + <short value="Code defined by a terminology system" /> + <definition value="A reference to a code defined by a terminology system." /> + <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> + <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="CodeableConcept.coding" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Coding" /> + </type> + <patternCoding> + <system value="http://terminology.hl7.org/CodeSystem/condition-ver-status" /> + </patternCoding> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1-8, C*E.10-22" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="union(., ./translation)" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:conditionVerificationStatus.id"> + <path value="Condition.verificationStatus.coding.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:conditionVerificationStatus.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.verificationStatus.coding.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:conditionVerificationStatus.system"> + <path value="Condition.verificationStatus.coding.system" /> + <short value="Identity of the terminology system" /> + <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> + <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> + <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.system" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="uri" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.3" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystem" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:conditionVerificationStatus.version"> + <path value="Condition.verificationStatus.coding.version" /> + <short value="Version of the system - if relevant" /> + <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> + <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.version" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.7" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystemVersion" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:conditionVerificationStatus.code"> + <path value="Condition.verificationStatus.coding.code" /> + <short value="Symbol in syntax defined by the system" /> + <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to refer to a particular code in the system." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.code" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="code" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./code" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:conditionVerificationStatus.display"> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> + <valueBoolean value="true" /> + </extension> + <path value="Condition.verificationStatus.coding.display" /> + <short value="Representation defined by the system" /> + <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.display" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.2 - but note this is not well followed" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV.displayName" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:conditionVerificationStatus.userSelected"> + <path value="Condition.verificationStatus.coding.userSelected" /> + <short value="If this coding was chosen directly by the user" /> + <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> + <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> + <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.userSelected" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="boolean" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="Sometimes implied by being first" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD.codingRationale" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:snomed"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.verificationStatus.coding" /> + <sliceName value="snomed" /> + <short value="Code defined by a terminology system" /> + <definition value="A reference to a code defined by a terminology system." /> + <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> + <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="CodeableConcept.coding" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Coding" /> + </type> + <patternCoding> + <system value="http://snomed.info/sct" /> + </patternCoding> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <binding> + <strength value="required" /> + <description value="Confirmed present | Definitely NOT present" /> + <valueSet value="https://www.netzwerk-universitaetsmedizin.de/fhir/ValueSet/verification-status" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1-8, C*E.10-22" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="union(., ./translation)" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:snomed.id"> + <path value="Condition.verificationStatus.coding.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:snomed.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.verificationStatus.coding.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:snomed.system"> + <path value="Condition.verificationStatus.coding.system" /> + <short value="Identity of the terminology system" /> + <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> + <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> + <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.system" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="uri" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.3" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystem" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:snomed.version"> + <path value="Condition.verificationStatus.coding.version" /> + <short value="Version of the system - if relevant" /> + <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> + <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.version" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.7" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystemVersion" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:snomed.code"> + <path value="Condition.verificationStatus.coding.code" /> + <short value="Symbol in syntax defined by the system" /> + <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to refer to a particular code in the system." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.code" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="code" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./code" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:snomed.display"> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> + <valueBoolean value="true" /> + </extension> + <path value="Condition.verificationStatus.coding.display" /> + <short value="Representation defined by the system" /> + <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.display" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.2 - but note this is not well followed" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV.displayName" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> + </mapping> + </element> + <element id="Condition.verificationStatus.coding:snomed.userSelected"> + <path value="Condition.verificationStatus.coding.userSelected" /> + <short value="If this coding was chosen directly by the user" /> + <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> + <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> + <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.userSelected" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="boolean" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="Sometimes implied by being first" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD.codingRationale" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> + </mapping> + </element> + <element id="Condition.verificationStatus.text"> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> + <valueBoolean value="true" /> + </extension> + <path value="Condition.verificationStatus.text" /> + <short value="Plain text representation of the concept" /> + <definition value="A human language representation of the concept as seen/selected/uttered by the user who entered the data and/or which represents the intended meaning of the user." /> + <comment value="Very often the text is the same as a displayName of one of the codings." /> + <requirements value="The codes from the terminologies do not always capture the correct meaning with all the nuances of the human using them, or sometimes there is no appropriate code at all. In these cases, the text is used to capture the full meaning of the source." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="CodeableConcept.text" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.9. But note many systems use C*E.2 for this" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./originalText[mediaType/code="text/plain"]/data" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.text rdfs:subPropertyOf dt:CD.originalText" /> + </mapping> + </element> + <element id="Condition.category"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.category" /> + <short value="problem-list-item | encounter-diagnosis" /> + <definition value="A category assigned to the condition." /> + <comment value="The categorization is often highly contextual and may appear poorly differentiated or not very useful in other contexts." /> + <min value="1" /> + <max value="*" /> + <base> + <path value="Condition.category" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="CodeableConcept" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <binding> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> + <valueString value="ConditionCategory" /> + </extension> + <strength value="extensible" /> + <description value="A category assigned to the condition." /> + <valueSet value="http://hl7.org/fhir/ValueSet/condition-category" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.class" /> + </mapping> + <mapping> + <identity value="sct-concept" /> + <map value="< 404684003 |Clinical finding|" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="'problem' if from PRB-3. 'diagnosis' if from DG1 segment in PV1 message" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".code" /> + </mapping> + </element> + <element id="Condition.category.id"> + <path value="Condition.category.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.category.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.category.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.category.coding"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.category.coding" /> + <slicing> + <discriminator> + <type value="pattern" /> + <path value="$this" /> + </discriminator> + <rules value="open" /> + </slicing> + <short value="Code defined by a terminology system" /> + <definition value="A reference to a code defined by a terminology system." /> + <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> + <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> + <min value="1" /> + <max value="*" /> + <base> + <path value="CodeableConcept.coding" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Coding" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1-8, C*E.10-22" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="union(., ./translation)" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> + </mapping> + </element> + <element id="Condition.category.coding:symptoms"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.category.coding" /> + <sliceName value="symptoms" /> + <short value="Code defined by a terminology system" /> + <definition value="A reference to a code defined by a terminology system." /> + <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> + <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="CodeableConcept.coding" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Coding" /> + </type> + <patternCoding> + <system value="http://loinc.org" /> + <code value="75325-1" /> + </patternCoding> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1-8, C*E.10-22" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="union(., ./translation)" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> + </mapping> + </element> + <element id="Condition.category.coding:symptoms.id"> + <path value="Condition.category.coding.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.category.coding:symptoms.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.category.coding.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.category.coding:symptoms.system"> + <path value="Condition.category.coding.system" /> + <short value="Identity of the terminology system" /> + <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> + <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> + <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.system" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="uri" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.3" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystem" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> + </mapping> + </element> + <element id="Condition.category.coding:symptoms.version"> + <path value="Condition.category.coding.version" /> + <short value="Version of the system - if relevant" /> + <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> + <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.version" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.7" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystemVersion" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> + </mapping> + </element> + <element id="Condition.category.coding:symptoms.code"> + <path value="Condition.category.coding.code" /> + <short value="Symbol in syntax defined by the system" /> + <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to refer to a particular code in the system." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.code" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="code" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./code" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> + </mapping> + </element> + <element id="Condition.category.coding:symptoms.display"> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> + <valueBoolean value="true" /> + </extension> + <path value="Condition.category.coding.display" /> + <short value="Representation defined by the system" /> + <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.display" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.2 - but note this is not well followed" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV.displayName" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> + </mapping> + </element> + <element id="Condition.category.coding:symptoms.userSelected"> + <path value="Condition.category.coding.userSelected" /> + <short value="If this coding was chosen directly by the user" /> + <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> + <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> + <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.userSelected" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="boolean" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="Sometimes implied by being first" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD.codingRationale" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> + </mapping> + </element> + <element id="Condition.category.text"> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> + <valueBoolean value="true" /> + </extension> + <path value="Condition.category.text" /> + <short value="Plain text representation of the concept" /> + <definition value="A human language representation of the concept as seen/selected/uttered by the user who entered the data and/or which represents the intended meaning of the user." /> + <comment value="Very often the text is the same as a displayName of one of the codings." /> + <requirements value="The codes from the terminologies do not always capture the correct meaning with all the nuances of the human using them, or sometimes there is no appropriate code at all. In these cases, the text is used to capture the full meaning of the source." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="CodeableConcept.text" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.9. But note many systems use C*E.2 for this" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./originalText[mediaType/code="text/plain"]/data" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.text rdfs:subPropertyOf dt:CD.originalText" /> + </mapping> + </element> + <element id="Condition.severity"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.severity" /> + <short value="Subjective severity of condition" /> + <definition value="A subjective assessment of the severity of the condition as evaluated by the clinician." /> + <comment value="Coding of the severity with a terminology is preferred, where possible." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Condition.severity" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="CodeableConcept" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <binding> + <strength value="preferred" /> + <description value="A subjective assessment of the severity of the condition as evaluated by the clinician." /> + <valueSet value="https://www.netzwerk-universitaetsmedizin.de/fhir/ValueSet/condition-severity" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.grade" /> + </mapping> + <mapping> + <identity value="sct-concept" /> + <map value="< 272141005 |Severities|" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="PRB-26 / ABS-3" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="Can be pre/post-coordinated into value. Or ./inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="severity"].value" /> + </mapping> + <mapping> + <identity value="sct-attr" /> + <map value="246112005" /> + </mapping> + </element> + <element id="Condition.code"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code" /> + <short value="Identification of the condition, problem or diagnosis" /> + <definition value="Identification of the condition, problem or diagnosis." /> + <comment value="Not all terminology uses fit this general pattern. In some cases, models should not use CodeableConcept and use Coding directly and provide their own structure for managing text, codings, translations and the relationship between elements and pre- and post-coordination." /> + <requirements value="0..1 to account for primarily narrative only resources." /> + <alias value="type" /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Condition.code" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="CodeableConcept" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <binding> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> + <valueString value="ConditionKind" /> + </extension> + <strength value="example" /> + <description value="Identification of the condition or diagnosis." /> + <valueSet value="http://hl7.org/fhir/ValueSet/condition-code" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> + </mapping> + <mapping> + <identity value="workflow" /> + <map value="Event.code" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.what[x]" /> + </mapping> + <mapping> + <identity value="sct-concept" /> + <map value="code 246090004 |Associated finding| (< 404684003 |Clinical finding| MINUS << 420134006 |Propensity to adverse reactions| MINUS << 473010000 |Hypersensitivity condition| MINUS << 79899007 |Drug interaction| MINUS << 69449002 |Drug action| MINUS << 441742003 |Evaluation finding| MINUS << 307824009 |Administrative status| MINUS << 385356007 |Tumor stage finding|) OR < 413350009 |Finding with explicit context| OR < 272379006 |Event|" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="PRB-3" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".value" /> + </mapping> + <mapping> + <identity value="sct-attr" /> + <map value="246090004" /> + </mapping> + </element> + <element id="Condition.code.id"> + <path value="Condition.code.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.code.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.code.coding"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.coding" /> + <slicing> + <discriminator> + <type value="pattern" /> + <path value="$this" /> + </discriminator> + <rules value="open" /> + </slicing> + <short value="Code defined by a terminology system" /> + <definition value="A reference to a code defined by a terminology system." /> + <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> + <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> + <min value="1" /> + <max value="*" /> + <base> + <path value="CodeableConcept.coding" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Coding" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1-8, C*E.10-22" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="union(., ./translation)" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> + </mapping> + </element> + <element id="Condition.code.coding:icd10-gm"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.coding" /> + <sliceName value="icd10-gm" /> + <short value="Code defined by a terminology system" /> + <definition value="A reference to a code defined by a terminology system." /> + <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> + <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="CodeableConcept.coding" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Coding" /> + </type> + <patternCoding> + <system value="http://fhir.de/CodeSystem/dimdi/icd-10-gm" /> + </patternCoding> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <binding> + <strength value="required" /> + <valueSet value="http://fhir.de/ValueSet/dimdi/icd-10-gm" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1-8, C*E.10-22" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="union(., ./translation)" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> + </mapping> + </element> + <element id="Condition.code.coding:icd10-gm.id"> + <path value="Condition.code.coding.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.code.coding:icd10-gm.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.coding.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.code.coding:icd10-gm.extension:Diagnosesicherheit"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.coding.extension" /> + <sliceName value="Diagnosesicherheit" /> + <short value="Optional Extensions Element" /> + <definition value="Optional Extension Element - found in all resources." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + <profile value="http://fhir.de/StructureDefinition/icd-10-gm-diagnosesicherheit" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mustSupport value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.code.coding:icd10-gm.extension:Seitenlokalisation"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.coding.extension" /> + <sliceName value="Seitenlokalisation" /> + <short value="Optional Extensions Element" /> + <definition value="Optional Extension Element - found in all resources." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + <profile value="http://fhir.de/StructureDefinition/seitenlokalisation" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mustSupport value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.code.coding:icd10-gm.extension:AusrufezeichenCode"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.coding.extension" /> + <sliceName value="AusrufezeichenCode" /> + <short value="Optional Extensions Element" /> + <definition value="Optional Extension Element - found in all resources." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + <profile value="http://fhir.de/StructureDefinition/icd-10-gm-ausrufezeichen" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mustSupport value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.code.coding:icd10-gm.extension:ManifestationsCode"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.coding.extension" /> + <sliceName value="ManifestationsCode" /> + <short value="Optional Extensions Element" /> + <definition value="Optional Extension Element - found in all resources." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + <profile value="http://fhir.de/StructureDefinition/icd-10-gm-manifestationscode" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mustSupport value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.code.coding:icd10-gm.extension:Primaercode"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.coding.extension" /> + <sliceName value="Primaercode" /> + <short value="Optional Extensions Element" /> + <definition value="Optional Extension Element - found in all resources." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + <profile value="http://fhir.de/StructureDefinition/icd-10-gm-primaercode" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mustSupport value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.code.coding:icd10-gm.system"> + <path value="Condition.code.coding.system" /> + <short value="Identity of the terminology system" /> + <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> + <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> + <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.system" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="uri" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.3" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystem" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> + </mapping> + </element> + <element id="Condition.code.coding:icd10-gm.version"> + <path value="Condition.code.coding.version" /> + <short value="Version of the system - if relevant" /> + <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> + <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.version" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.7" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystemVersion" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> + </mapping> + </element> + <element id="Condition.code.coding:icd10-gm.code"> + <path value="Condition.code.coding.code" /> + <short value="Symbol in syntax defined by the system" /> + <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to refer to a particular code in the system." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.code" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="code" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./code" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> + </mapping> + </element> + <element id="Condition.code.coding:icd10-gm.display"> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> + <valueBoolean value="true" /> + </extension> + <path value="Condition.code.coding.display" /> + <short value="Representation defined by the system" /> + <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.display" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.2 - but note this is not well followed" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV.displayName" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> + </mapping> + </element> + <element id="Condition.code.coding:icd10-gm.userSelected"> + <path value="Condition.code.coding.userSelected" /> + <short value="If this coding was chosen directly by the user" /> + <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> + <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> + <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.userSelected" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="boolean" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="Sometimes implied by being first" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD.codingRationale" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> + </mapping> + </element> + <element id="Condition.code.coding:alpha-id"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.coding" /> + <sliceName value="alpha-id" /> + <short value="Code defined by a terminology system" /> + <definition value="A reference to a code defined by a terminology system." /> + <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> + <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="CodeableConcept.coding" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Coding" /> + </type> + <patternCoding> + <system value="http://fhir.de/CodeSystem/dimdi/alpha-id" /> + </patternCoding> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <binding> + <strength value="required" /> + <valueSet value="http://fhir.de/ValueSet/dimdi/alpha-id" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1-8, C*E.10-22" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="union(., ./translation)" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> + </mapping> + </element> + <element id="Condition.code.coding:alpha-id.id"> + <path value="Condition.code.coding.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.code.coding:alpha-id.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.coding.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.code.coding:alpha-id.system"> + <path value="Condition.code.coding.system" /> + <short value="Identity of the terminology system" /> + <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> + <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> + <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.system" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="uri" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.3" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystem" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> + </mapping> + </element> + <element id="Condition.code.coding:alpha-id.version"> + <path value="Condition.code.coding.version" /> + <short value="Version of the system - if relevant" /> + <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> + <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.version" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.7" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystemVersion" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> + </mapping> + </element> + <element id="Condition.code.coding:alpha-id.code"> + <path value="Condition.code.coding.code" /> + <short value="Symbol in syntax defined by the system" /> + <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to refer to a particular code in the system." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.code" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="code" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./code" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> + </mapping> + </element> + <element id="Condition.code.coding:alpha-id.display"> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> + <valueBoolean value="true" /> + </extension> + <path value="Condition.code.coding.display" /> + <short value="Representation defined by the system" /> + <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.display" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.2 - but note this is not well followed" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV.displayName" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> + </mapping> + </element> + <element id="Condition.code.coding:alpha-id.userSelected"> + <path value="Condition.code.coding.userSelected" /> + <short value="If this coding was chosen directly by the user" /> + <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> + <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> + <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.userSelected" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="boolean" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="Sometimes implied by being first" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD.codingRationale" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> + </mapping> + </element> + <element id="Condition.code.coding:sct"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.coding" /> + <sliceName value="sct" /> + <short value="Code defined by a terminology system" /> + <definition value="A reference to a code defined by a terminology system." /> + <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> + <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="CodeableConcept.coding" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Coding" /> + </type> + <patternCoding> + <system value="http://snomed.info/sct" /> + </patternCoding> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <binding> + <strength value="required" /> + <valueSet value="https://www.netzwerk-universitaetsmedizin.de/fhir/ValueSet/sars-cov-2-symptoms" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1-8, C*E.10-22" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="union(., ./translation)" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> + </mapping> + </element> + <element id="Condition.code.coding:sct.id"> + <path value="Condition.code.coding.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.code.coding:sct.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.coding.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.code.coding:sct.system"> + <path value="Condition.code.coding.system" /> + <short value="Identity of the terminology system" /> + <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> + <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> + <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.system" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="uri" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.3" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystem" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> + </mapping> + </element> + <element id="Condition.code.coding:sct.version"> + <path value="Condition.code.coding.version" /> + <short value="Version of the system - if relevant" /> + <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> + <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.version" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.7" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystemVersion" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> + </mapping> + </element> + <element id="Condition.code.coding:sct.code"> + <path value="Condition.code.coding.code" /> + <short value="Symbol in syntax defined by the system" /> + <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to refer to a particular code in the system." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.code" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="code" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./code" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> + </mapping> + </element> + <element id="Condition.code.coding:sct.display"> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> + <valueBoolean value="true" /> + </extension> + <path value="Condition.code.coding.display" /> + <short value="Representation defined by the system" /> + <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.display" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.2 - but note this is not well followed" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV.displayName" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> + </mapping> + </element> + <element id="Condition.code.coding:sct.userSelected"> + <path value="Condition.code.coding.userSelected" /> + <short value="If this coding was chosen directly by the user" /> + <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> + <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> + <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.userSelected" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="boolean" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="Sometimes implied by being first" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD.codingRationale" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> + </mapping> + </element> + <element id="Condition.code.coding:orphanet"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.coding" /> + <sliceName value="orphanet" /> + <short value="Code defined by a terminology system" /> + <definition value="A reference to a code defined by a terminology system." /> + <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> + <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> + <min value="0" /> + <max value="0" /> + <base> + <path value="CodeableConcept.coding" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Coding" /> + </type> + <patternCoding> + <system value="http://www.orpha.net" /> + </patternCoding> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1-8, C*E.10-22" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="union(., ./translation)" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> + </mapping> + </element> + <element id="Condition.code.coding:orphanet.id"> + <path value="Condition.code.coding.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.code.coding:orphanet.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.code.coding.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.code.coding:orphanet.system"> + <path value="Condition.code.coding.system" /> + <short value="Identity of the terminology system" /> + <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> + <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> + <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.system" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="uri" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.3" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystem" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> + </mapping> + </element> + <element id="Condition.code.coding:orphanet.version"> + <path value="Condition.code.coding.version" /> + <short value="Version of the system - if relevant" /> + <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> + <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.version" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.7" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystemVersion" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> + </mapping> + </element> + <element id="Condition.code.coding:orphanet.code"> + <path value="Condition.code.coding.code" /> + <short value="Symbol in syntax defined by the system" /> + <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to refer to a particular code in the system." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.code" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="code" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./code" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> + </mapping> + </element> + <element id="Condition.code.coding:orphanet.display"> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> + <valueBoolean value="true" /> + </extension> + <path value="Condition.code.coding.display" /> + <short value="Representation defined by the system" /> + <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.display" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.2 - but note this is not well followed" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV.displayName" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> + </mapping> + </element> + <element id="Condition.code.coding:orphanet.userSelected"> + <path value="Condition.code.coding.userSelected" /> + <short value="If this coding was chosen directly by the user" /> + <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> + <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> + <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.userSelected" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="boolean" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="Sometimes implied by being first" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD.codingRationale" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> + </mapping> + </element> + <element id="Condition.code.text"> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> + <valueBoolean value="true" /> + </extension> + <path value="Condition.code.text" /> + <short value="Plain text representation of the concept" /> + <definition value="A human language representation of the concept as seen/selected/uttered by the user who entered the data and/or which represents the intended meaning of the user." /> + <comment value="Very often the text is the same as a displayName of one of the codings." /> + <requirements value="The codes from the terminologies do not always capture the correct meaning with all the nuances of the human using them, or sometimes there is no appropriate code at all. In these cases, the text is used to capture the full meaning of the source." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="CodeableConcept.text" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.9. But note many systems use C*E.2 for this" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./originalText[mediaType/code="text/plain"]/data" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.text rdfs:subPropertyOf dt:CD.originalText" /> + </mapping> + </element> + <element id="Condition.bodySite"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.bodySite" /> + <short value="Anatomical location, if relevant" /> + <definition value="The anatomical location where this condition manifests itself." /> + <comment value="Only used if not implicit in code found in Condition.code. If the use case requires attributes from the BodySite resource (e.g. to identify and track separately) then use the standard extension [bodySite](extension-bodysite.html). May be a summary code, or a reference to a very precise definition of the location, or both." /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Condition.bodySite" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="CodeableConcept" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <binding> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> + <valueString value="BodySite" /> + </extension> + <strength value="example" /> + <description value="Codes describing anatomical locations. May include laterality." /> + <valueSet value="http://hl7.org/fhir/ValueSet/body-site" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> + </mapping> + <mapping> + <identity value="sct-concept" /> + <map value="< 442083009 |Anatomical or acquired body structure|" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".targetBodySiteCode" /> + </mapping> + <mapping> + <identity value="sct-attr" /> + <map value="363698007" /> + </mapping> + </element> + <element id="Condition.bodySite.id"> + <path value="Condition.bodySite.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.bodySite.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.bodySite.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.bodySite.coding"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.bodySite.coding" /> + <slicing> + <discriminator> + <type value="pattern" /> + <path value="system" /> + </discriminator> + <rules value="open" /> + </slicing> + <short value="Code defined by a terminology system" /> + <definition value="A reference to a code defined by a terminology system." /> + <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> + <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> + <min value="1" /> + <max value="*" /> + <base> + <path value="CodeableConcept.coding" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Coding" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1-8, C*E.10-22" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="union(., ./translation)" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> + </mapping> + </element> + <element id="Condition.bodySite.coding:snomed-ct"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.bodySite.coding" /> + <sliceName value="snomed-ct" /> + <short value="Code defined by a terminology system" /> + <definition value="A reference to a code defined by a terminology system." /> + <comment value="Codes may be defined very casually in enumerations, or code lists, up to very formal definitions such as SNOMED CT - see the HL7 v3 Core Principles for more information. Ordering of codings is undefined and SHALL NOT be used to infer meaning. Generally, at most only one of the coding values will be labeled as UserSelected = true." /> + <requirements value="Allows for alternative encodings within a code system, and translations to other code systems." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="CodeableConcept.coding" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Coding" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE subset one of the sets of component 1-3 or 4-6" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding rdfs:subClassOf dt:CDCoding" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1-8, C*E.10-22" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="union(., ./translation)" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.coding rdfs:subPropertyOf dt:CD.coding" /> + </mapping> + </element> + <element id="Condition.bodySite.coding:snomed-ct.id"> + <path value="Condition.bodySite.coding.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.bodySite.coding:snomed-ct.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.bodySite.coding.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.bodySite.coding:snomed-ct.system"> + <path value="Condition.bodySite.coding.system" /> + <short value="Identity of the terminology system" /> + <definition value="The identification of the code system that defines the meaning of the symbol in the code." /> + <comment value="The URI may be an OID (urn:oid:...) or a UUID (urn:uuid:...). OIDs and UUIDs SHALL be references to the HL7 OID registry. Otherwise, the URI should come from HL7's list of FHIR defined special URIs or it should reference to some definition that establishes the system clearly and unambiguously." /> + <requirements value="Need to be unambiguous about the source of the definition of the symbol." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.system" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="uri" /> + </type> + <patternUri value="http://snomed.info/sct" /> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.3" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystem" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.system rdfs:subPropertyOf dt:CDCoding.codeSystem" /> + </mapping> + </element> + <element id="Condition.bodySite.coding:snomed-ct.version"> + <path value="Condition.bodySite.coding.version" /> + <short value="Version of the system - if relevant" /> + <definition value="The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged." /> + <comment value="Where the terminology does not clearly define what string should be used to identify code system versions, the recommendation is to use the date (expressed in FHIR date format) on which that version was officially published as the version date." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.version" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.7" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./codeSystemVersion" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.version rdfs:subPropertyOf dt:CDCoding.codeSystemVersion" /> + </mapping> + </element> + <element id="Condition.bodySite.coding:snomed-ct.code"> + <path value="Condition.bodySite.coding.code" /> + <short value="Symbol in syntax defined by the system" /> + <definition value="A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination)." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to refer to a particular code in the system." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Coding.code" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="code" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.1" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./code" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.code rdfs:subPropertyOf dt:CDCoding.code" /> + </mapping> + </element> + <element id="Condition.bodySite.coding:snomed-ct.display"> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> + <valueBoolean value="true" /> + </extension> + <path value="Condition.bodySite.coding.display" /> + <short value="Representation defined by the system" /> + <definition value="A representation of the meaning of the code in the system, following the rules of the system." /> + <comment value="Note that FHIR strings SHALL NOT exceed 1MB in size" /> + <requirements value="Need to be able to carry a human-readable meaning of the code for readers that do not know the system." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.display" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.2 - but note this is not well followed" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CV.displayName" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.display rdfs:subPropertyOf dt:CDCoding.displayName" /> + </mapping> + </element> + <element id="Condition.bodySite.coding:snomed-ct.userSelected"> + <path value="Condition.bodySite.coding.userSelected" /> + <short value="If this coding was chosen directly by the user" /> + <definition value="Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays)." /> + <comment value="Amongst a set of alternatives, a directly chosen code is the most appropriate starting point for new translations. There is some ambiguity about what exactly 'directly chosen' implies, and trading partner agreement may be needed to clarify the use of this element and its consequences more completely." /> + <requirements value="This has been identified as a clinical safety criterium - that this exact system/code pair was chosen explicitly, rather than inferred by the system based on some rules or language processing." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Coding.userSelected" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="boolean" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="Sometimes implied by being first" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD.codingRationale" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:Coding.userSelected fhir:mapsTo dt:CDCoding.codingRationale. fhir:Coding.userSelected fhir:hasMap fhir:Coding.userSelected.map. fhir:Coding.userSelected.map a fhir:Map; fhir:target dt:CDCoding.codingRationale. fhir:Coding.userSelected\#true a [ fhir:source "true"; fhir:target dt:CDCoding.codingRationale\#O ]" /> + </mapping> + </element> + <element id="Condition.bodySite.text"> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable"> + <valueBoolean value="true" /> + </extension> + <path value="Condition.bodySite.text" /> + <short value="Plain text representation of the concept" /> + <definition value="A human language representation of the concept as seen/selected/uttered by the user who entered the data and/or which represents the intended meaning of the user." /> + <comment value="Very often the text is the same as a displayName of one of the codings." /> + <requirements value="The codes from the terminologies do not always capture the correct meaning with all the nuances of the human using them, or sometimes there is no appropriate code at all. In these cases, the text is used to capture the full meaning of the source." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="CodeableConcept.text" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="C*E.9. But note many systems use C*E.2 for this" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./originalText[mediaType/code="text/plain"]/data" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept.text rdfs:subPropertyOf dt:CD.originalText" /> + </mapping> + </element> + <element id="Condition.subject"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.subject" /> + <short value="A reference from one resource to another" /> + <definition value="A reference from one resource to another." /> + <comment value="References SHALL be a reference to an actual FHIR resource, and SHALL be resolveable (allowing for access control, temporary unavailability, etc.). Resolution can be either by retrieval from the URL, or, where applicable by resource type, by treating an absolute reference as a canonical URL and looking it up in a local registry/repository." /> + <requirements value="Group is typically used for veterinary or public health use cases." /> + <alias value="patient" /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Condition.subject" /> + <min value="1" /> + <max value="1" /> + </base> + <type> + <code value="Reference" /> + <profile value="https://www.medizininformatik-initiative.de/fhir/core/StructureDefinition/MII-Reference" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/Patient" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/Group" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ref-1" /> + <severity value="error" /> + <human value="SHALL have a contained resource if a local reference is provided" /> + <expression value="reference.startsWith('#').not() or (reference.substring(1).trace('url') in %rootResource.contained.id.trace('ids'))" /> + <xpath value="not(starts-with(f:reference/@value, '#')) or exists(ancestor::*[self::f:entry or self::f:parameter]/f:resource/f:*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')]|/*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> + </constraint> + <constraint> + <key value="mii-reference-1" /> + <severity value="error" /> + <human value="Either reference.reference OR reference.identifier exists" /> + <expression value="($this.reference.exists() or ($this.identifier.value.exists() and $this.identifier.system.exists())) xor $this.extension('http://hl7.org/fhir/StructureDefinition/data-absent-reason').exists()" /> + <source value="https://www.medizininformatik-initiative.de/fhir/core/StructureDefinition/MII-Reference" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="The target of a resource reference is a RIM entry point (Act, Role, or Entity)" /> + </mapping> + <mapping> + <identity value="workflow" /> + <map value="Event.subject" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.subject[x]" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="PID-3" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".participation[typeCode=SBJ].role[classCode=PAT]" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.subject" /> + </mapping> + </element> + <element id="Condition.encounter"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.encounter" /> + <short value="Encounter created as part of" /> + <definition value="The Encounter during which this Condition was created or to which the creation of this record is tightly associated." /> + <comment value="This will typically be the encounter the event occurred within, but some activities may be initiated prior to or after the official completion of an encounter but still be tied to the context of the encounter. This record indicates the encounter this particular record is associated with. In the case of a "new" diagnosis reflecting ongoing/revised information about the condition, this might be distinct from the first encounter in which the underlying condition was first "known"." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Condition.encounter" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="Reference" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/Encounter" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ref-1" /> + <severity value="error" /> + <human value="SHALL have a contained resource if a local reference is provided" /> + <expression value="reference.startsWith('#').not() or (reference.substring(1).trace('url') in %rootResource.contained.id.trace('ids'))" /> + <xpath value="not(starts-with(f:reference/@value, '#')) or exists(ancestor::*[self::f:entry or self::f:parameter]/f:resource/f:*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')]|/*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="The target of a resource reference is a RIM entry point (Act, Role, or Entity)" /> + </mapping> + <mapping> + <identity value="workflow" /> + <map value="Event.context" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.context" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="PV1-19 (+PV1-54)" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN]" /> + </mapping> + </element> + <element id="Condition.onset[x]"> + <path value="Condition.onset[x]" /> + <slicing> + <discriminator> + <type value="type" /> + <path value="$this" /> + </discriminator> + <rules value="closed" /> + </slicing> + <short value="Estimated or actual date, date-time, or age" /> + <definition value="Estimated or actual date or date-time the condition began, in the opinion of the clinician." /> + <comment value="Age is generally used when the patient reports an age at which the Condition began to occur." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Condition.onset[x]" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="dateTime" /> + </type> + <type> + <code value="Period" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="workflow" /> + <map value="Event.occurrence[x]" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.init" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="PRB-16" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".effectiveTime.low or .inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="age at onset"].value" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetPeriod"> + <path value="Condition.onset[x]" /> + <sliceName value="onsetPeriod" /> + <short value="Estimated or actual date, date-time, or age" /> + <definition value="Estimated or actual date or date-time the condition began, in the opinion of the clinician." /> + <comment value="Age is generally used when the patient reports an age at which the Condition began to occur." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Condition.onset[x]" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="Period" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="workflow" /> + <map value="Event.occurrence[x]" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.init" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="PRB-16" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".effectiveTime.low or .inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="age at onset"].value" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetPeriod.id"> + <path value="Condition.onset[x].id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetPeriod.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.onset[x].extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetPeriod.extension:dataAbsentReason"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.onset[x].extension" /> + <sliceName value="dataAbsentReason" /> + <short value="unknown | asked | temp | notasked | masked | unsupported | astext | error" /> + <definition value="Provides a reason why the expected value or elements in the element that is extended are missing." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + <profile value="http://hl7.org/fhir/StructureDefinition/data-absent-reason" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="ANY.nullFlavor" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetPeriod.start"> + <path value="Condition.onset[x].start" /> + <short value="Starting time with inclusive boundary" /> + <definition value="The start of the period. The boundary is inclusive." /> + <comment value="If the low element is missing, the meaning is that the low boundary is not known." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Period.start" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="dateTime" /> + </type> + <condition value="ele-1" /> + <condition value="per-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="DR.1" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./low" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetPeriod.start.id"> + <path value="Condition.onset[x].start.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetPeriod.start.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.onset[x].start.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetPeriod.start.extension:lebensphase-von"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.onset[x].start.extension" /> + <sliceName value="lebensphase-von" /> + <short value="Optional Extensions Element" /> + <definition value="Optional Extension Element - found in all resources." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + <profile value="https://fhir.kbv.de/StructureDefinition/KBV_EX_Base_Stage_Life" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mustSupport value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetPeriod.start.value"> + <path value="Condition.onset[x].start.value" /> + <representation value="xmlAttr" /> + <short value="Primitive value for dateTime" /> + <definition value="Primitive value for dateTime" /> + <min value="0" /> + <max value="1" /> + <base> + <path value="dateTime.value" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="dateTime" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/regex"> + <valueString value="([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?" /> + </extension> + <code value="http://hl7.org/fhirpath/System.DateTime" /> + </type> + </element> + <element id="Condition.onset[x]:onsetPeriod.end"> + <path value="Condition.onset[x].end" /> + <short value="End time with inclusive boundary, if not ongoing" /> + <definition value="The end of the period. If the end of the period is missing, it means no end was known or planned at the time the instance was created. The start may be in the past, and the end date in the future, which means that period is expected/planned to end at that time." /> + <comment value="The high value includes any matching date/time. i.e. 2012-02-03T10:00:00 is in a period that has an end value of 2012-02-03." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Period.end" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="dateTime" /> + </type> + <meaningWhenMissing value="If the end of the period is missing, it means that the period is ongoing" /> + <condition value="ele-1" /> + <condition value="per-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="DR.2" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./high" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetPeriod.end.id"> + <path value="Condition.onset[x].end.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetPeriod.end.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.onset[x].end.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetPeriod.end.extension:lebensphase-bis"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.onset[x].end.extension" /> + <sliceName value="lebensphase-bis" /> + <short value="Optional Extensions Element" /> + <definition value="Optional Extension Element - found in all resources." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + <profile value="https://fhir.kbv.de/StructureDefinition/KBV_EX_Base_Stage_Life" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mustSupport value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetPeriod.end.value"> + <path value="Condition.onset[x].end.value" /> + <representation value="xmlAttr" /> + <short value="Primitive value for dateTime" /> + <definition value="Primitive value for dateTime" /> + <min value="0" /> + <max value="1" /> + <base> + <path value="dateTime.value" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="dateTime" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/regex"> + <valueString value="([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?" /> + </extension> + <code value="http://hl7.org/fhirpath/System.DateTime" /> + </type> + </element> + <element id="Condition.onset[x]:onsetDateTime"> + <path value="Condition.onset[x]" /> + <sliceName value="onsetDateTime" /> + <short value="Estimated or actual date, date-time, or age" /> + <definition value="Estimated or actual date or date-time the condition began, in the opinion of the clinician." /> + <comment value="Age is generally used when the patient reports an age at which the Condition began to occur." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Condition.onset[x]" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="dateTime" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="workflow" /> + <map value="Event.occurrence[x]" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.init" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="PRB-16" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".effectiveTime.low or .inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="age at onset"].value" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetDateTime.id"> + <path value="Condition.onset[x].id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetDateTime.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.onset[x].extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetDateTime.extension:dataAbsentReason"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.onset[x].extension" /> + <sliceName value="dataAbsentReason" /> + <short value="unknown | asked | temp | notasked | masked | unsupported | astext | error" /> + <definition value="Provides a reason why the expected value or elements in the element that is extended are missing." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + <profile value="http://hl7.org/fhir/StructureDefinition/data-absent-reason" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="ANY.nullFlavor" /> + </mapping> + </element> + <element id="Condition.onset[x]:onsetDateTime.value"> + <path value="Condition.onset[x].value" /> + <representation value="xmlAttr" /> + <short value="Primitive value for dateTime" /> + <definition value="Primitive value for dateTime" /> + <min value="0" /> + <max value="1" /> + <base> + <path value="dateTime.value" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="dateTime" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/regex"> + <valueString value="([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?" /> + </extension> + <code value="http://hl7.org/fhirpath/System.DateTime" /> + </type> + </element> + <element id="Condition.abatement[x]"> + <path value="Condition.abatement[x]" /> + <short value="When in resolution/remission" /> + <definition value="The date or estimated date that the condition resolved or went into remission. This is called "abatement" because of the many overloaded connotations associated with "remission" or "resolution" - Conditions are never really resolved, but they can abate." /> + <comment value="There is no explicit distinction between resolution and remission because in many cases the distinction is not clear. Age is generally used when the patient reports an age at which the Condition abated. If there is no abatement element, it is unknown whether the condition has resolved or entered remission; applications and users should generally assume that the condition is still valid. When abatementString exists, it implies the condition is abated." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Condition.abatement[x]" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="dateTime" /> + </type> + <type> + <code value="Age" /> + </type> + <type> + <code value="Period" /> + </type> + <type> + <code value="Range" /> + </type> + <type> + <code value="string" /> + </type> + <condition value="ele-1" /> + <condition value="con-4" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.done[x]" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".effectiveTime.high or .inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="age at remission"].value or .inboundRelationship[typeCode=SUBJ]source[classCode=CONC, moodCode=EVN].status=completed" /> + </mapping> + </element> + <element id="Condition.recordedDate"> + <path value="Condition.recordedDate" /> + <short value="Date record was first recorded" /> + <definition value="The recordedDate represents when this particular Condition record was created in the system, which is often a system-generated date." /> + <min value="1" /> + <max value="1" /> + <base> + <path value="Condition.recordedDate" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="dateTime" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.recorded" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="REL-11" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".participation[typeCode=AUT].time" /> + </mapping> + </element> + <element id="Condition.recorder"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.recorder" /> + <short value="Who recorded the condition" /> + <definition value="Individual who recorded the record and takes responsibility for its content." /> + <comment value="References SHALL be a reference to an actual FHIR resource, and SHALL be resolveable (allowing for access control, temporary unavailability, etc.). Resolution can be either by retrieval from the URL, or, where applicable by resource type, by treating an absolute reference as a canonical URL and looking it up in a local registry/repository." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Condition.recorder" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="Reference" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/Practitioner" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/PractitionerRole" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/Patient" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/RelatedPerson" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ref-1" /> + <severity value="error" /> + <human value="SHALL have a contained resource if a local reference is provided" /> + <expression value="reference.startsWith('#').not() or (reference.substring(1).trace('url') in %rootResource.contained.id.trace('ids'))" /> + <xpath value="not(starts-with(f:reference/@value, '#')) or exists(ancestor::*[self::f:entry or self::f:parameter]/f:resource/f:*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')]|/*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="The target of a resource reference is a RIM entry point (Act, Role, or Entity)" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.author" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".participation[typeCode=AUT].role" /> + </mapping> + </element> + <element id="Condition.asserter"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.asserter" /> + <short value="Person who asserts this condition" /> + <definition value="Individual who is making the condition statement." /> + <comment value="References SHALL be a reference to an actual FHIR resource, and SHALL be resolveable (allowing for access control, temporary unavailability, etc.). Resolution can be either by retrieval from the URL, or, where applicable by resource type, by treating an absolute reference as a canonical URL and looking it up in a local registry/repository." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Condition.asserter" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="Reference" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/Practitioner" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/PractitionerRole" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/Patient" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/RelatedPerson" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ref-1" /> + <severity value="error" /> + <human value="SHALL have a contained resource if a local reference is provided" /> + <expression value="reference.startsWith('#').not() or (reference.substring(1).trace('url') in %rootResource.contained.id.trace('ids'))" /> + <xpath value="not(starts-with(f:reference/@value, '#')) or exists(ancestor::*[self::f:entry or self::f:parameter]/f:resource/f:*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')]|/*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="The target of a resource reference is a RIM entry point (Act, Role, or Entity)" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.source" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="REL-7.1 identifier + REL-7.12 type code" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".participation[typeCode=INF].role" /> + </mapping> + </element> + <element id="Condition.stage"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.stage" /> + <short value="Stage/grade, usually assessed formally" /> + <definition value="Clinical stage or grade of a condition. May include formal severity assessments." /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Condition.stage" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="BackboneElement" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="con-1" /> + <severity value="error" /> + <human value="Stage SHALL have summary or assessment" /> + <expression value="summary.exists() or assessment.exists()" /> + <xpath value="exists(f:summary) or exists(f:assessment)" /> + <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="stage/grade"]" /> + </mapping> + </element> + <element id="Condition.stage.id"> + <path value="Condition.stage.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.stage.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.stage.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.stage.modifierExtension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.stage.modifierExtension" /> + <short value="Extensions that cannot be ignored even if unrecognized" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions. Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself)." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <requirements value="Modifier extensions allow for extensions that *cannot* be safely ignored to be clearly distinguished from the vast majority of extensions which can be safely ignored. This promotes interoperability by eliminating the need for implementers to prohibit the presence of extensions. For further information, see the [definition of modifier extensions](extensibility.html#modifierExtension)." /> + <alias value="extensions" /> + <alias value="user content" /> + <alias value="modifiers" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="BackboneElement.modifierExtension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <isModifier value="true" /> + <isModifierReason value="Modifier extensions are expected to modify the meaning or interpretation of the element that contains them" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.stage.summary"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.stage.summary" /> + <short value="Simple summary (disease specific)" /> + <definition value="A simple summary of the stage such as "Stage 3". The determination of the stage is disease-specific." /> + <comment value="Not all terminology uses fit this general pattern. In some cases, models should not use CodeableConcept and use Coding directly and provide their own structure for managing text, codings, translations and the relationship between elements and pre- and post-coordination." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Condition.stage.summary" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="CodeableConcept" /> + </type> + <condition value="ele-1" /> + <condition value="con-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <binding> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> + <valueString value="ConditionStage" /> + </extension> + <strength value="example" /> + <description value="Codes describing condition stages (e.g. Cancer stages)." /> + <valueSet value="http://hl7.org/fhir/ValueSet/condition-stage" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> + </mapping> + <mapping> + <identity value="sct-concept" /> + <map value="< 254291000 |Staging and scales|" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="PRB-14" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".value" /> + </mapping> + </element> + <element id="Condition.stage.assessment"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.stage.assessment" /> + <short value="Formal record of assessment" /> + <definition value="Reference to a formal record of the evidence on which the staging assessment is based." /> + <comment value="References SHALL be a reference to an actual FHIR resource, and SHALL be resolveable (allowing for access control, temporary unavailability, etc.). Resolution can be either by retrieval from the URL, or, where applicable by resource type, by treating an absolute reference as a canonical URL and looking it up in a local registry/repository." /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Condition.stage.assessment" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Reference" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/ClinicalImpression" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/DiagnosticReport" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/Observation" /> + </type> + <condition value="ele-1" /> + <condition value="con-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ref-1" /> + <severity value="error" /> + <human value="SHALL have a contained resource if a local reference is provided" /> + <expression value="reference.startsWith('#').not() or (reference.substring(1).trace('url') in %rootResource.contained.id.trace('ids'))" /> + <xpath value="not(starts-with(f:reference/@value, '#')) or exists(ancestor::*[self::f:entry or self::f:parameter]/f:resource/f:*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')]|/*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="The target of a resource reference is a RIM entry point (Act, Role, or Entity)" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".self" /> + </mapping> + </element> + <element id="Condition.stage.type"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.stage.type" /> + <short value="Kind of staging" /> + <definition value="The kind of staging, such as pathological or clinical staging." /> + <comment value="Not all terminology uses fit this general pattern. In some cases, models should not use CodeableConcept and use Coding directly and provide their own structure for managing text, codings, translations and the relationship between elements and pre- and post-coordination." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Condition.stage.type" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <code value="CodeableConcept" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <binding> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> + <valueString value="ConditionStageType" /> + </extension> + <strength value="example" /> + <description value="Codes describing the kind of condition staging (e.g. clinical or pathological)." /> + <valueSet value="http://hl7.org/fhir/ValueSet/condition-stage-type" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="./inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="stage type"]" /> + </mapping> + </element> + <element id="Condition.evidence"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.evidence" /> + <short value="Supporting evidence" /> + <definition value="Supporting evidence / manifestations that are the basis of the Condition's verification status, such as evidence that confirmed or refuted the condition." /> + <comment value="The evidence may be a simple list of coded symptoms/manifestations, or references to observations or formal assessments, or both." /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Condition.evidence" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="BackboneElement" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="con-2" /> + <severity value="error" /> + <human value="evidence SHALL have code or details" /> + <expression value="code.exists() or detail.exists()" /> + <xpath value="exists(f:code) or exists(f:detail)" /> + <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".outboundRelationship[typeCode=SPRT].target[classCode=OBS, moodCode=EVN]" /> + </mapping> + </element> + <element id="Condition.evidence.id"> + <path value="Condition.evidence.id" /> + <representation value="xmlAttr" /> + <short value="Unique id for inter-element referencing" /> + <definition value="Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." /> + <min value="0" /> + <max value="1" /> + <base> + <path value="Element.id" /> + <min value="0" /> + <max value="1" /> + </base> + <type> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type"> + <valueUrl value="string" /> + </extension> + <code value="http://hl7.org/fhirpath/System.String" /> + </type> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + </element> + <element id="Condition.evidence.extension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.evidence.extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <description value="Extensions are always sliced by (at least) url" /> + <rules value="open" /> + </slicing> + <short value="Additional content defined by implementations" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <alias value="extensions" /> + <alias value="user content" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Element.extension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.evidence.modifierExtension"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.evidence.modifierExtension" /> + <short value="Extensions that cannot be ignored even if unrecognized" /> + <definition value="May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions. Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself)." /> + <comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." /> + <requirements value="Modifier extensions allow for extensions that *cannot* be safely ignored to be clearly distinguished from the vast majority of extensions which can be safely ignored. This promotes interoperability by eliminating the need for implementers to prohibit the presence of extensions. For further information, see the [definition of modifier extensions](extensibility.html#modifierExtension)." /> + <alias value="extensions" /> + <alias value="user content" /> + <alias value="modifiers" /> + <min value="0" /> + <max value="*" /> + <base> + <path value="BackboneElement.modifierExtension" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Extension" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ext-1" /> + <severity value="error" /> + <human value="Must have either extensions or value[x], not both" /> + <expression value="extension.exists() != value.exists()" /> + <xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/DomainResource" /> + </constraint> + <isModifier value="true" /> + <isModifierReason value="Modifier extensions are expected to modify the meaning or interpretation of the element that contains them" /> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="N/A" /> + </mapping> + </element> + <element id="Condition.evidence.code"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.evidence.code" /> + <short value="Manifestation/symptom" /> + <definition value="A manifestation or symptom that led to the recording of this condition." /> + <comment value="Not all terminology uses fit this general pattern. In some cases, models should not use CodeableConcept and use Coding directly and provide their own structure for managing text, codings, translations and the relationship between elements and pre- and post-coordination." /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Condition.evidence.code" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="CodeableConcept" /> + </type> + <condition value="ele-1" /> + <condition value="con-2" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <isSummary value="true" /> + <binding> + <extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName"> + <valueString value="ManifestationOrSymptom" /> + </extension> + <strength value="example" /> + <description value="Codes that describe the manifestation or symptoms of a condition." /> + <valueSet value="http://hl7.org/fhir/ValueSet/manifestation-or-symptom" /> + </binding> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="CE/CNE/CWE" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="CD" /> + </mapping> + <mapping> + <identity value="orim" /> + <map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" /> + </mapping> + <mapping> + <identity value="workflow" /> + <map value="Event.reasonCode" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.why[x]" /> + </mapping> + <mapping> + <identity value="sct-concept" /> + <map value="< 404684003 |Clinical finding|" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="[code="diagnosis"].value" /> + </mapping> + </element> + <element id="Condition.evidence.detail"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.evidence.detail" /> + <short value="Supporting information found elsewhere" /> + <definition value="Links to other relevant information, including pathology reports." /> + <comment value="References SHALL be a reference to an actual FHIR resource, and SHALL be resolveable (allowing for access control, temporary unavailability, etc.). Resolution can be either by retrieval from the URL, or, where applicable by resource type, by treating an absolute reference as a canonical URL and looking it up in a local registry/repository." /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Condition.evidence.detail" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Reference" /> + <targetProfile value="http://hl7.org/fhir/StructureDefinition/Resource" /> + </type> + <condition value="ele-1" /> + <condition value="con-2" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <constraint> + <key value="ref-1" /> + <severity value="error" /> + <human value="SHALL have a contained resource if a local reference is provided" /> + <expression value="reference.startsWith('#').not() or (reference.substring(1).trace('url') in %rootResource.contained.id.trace('ids'))" /> + <xpath value="not(starts-with(f:reference/@value, '#')) or exists(ancestor::*[self::f:entry or self::f:parameter]/f:resource/f:*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')]|/*/f:contained/f:*[f:id/@value=substring-after(current()/f:reference/@value, '#')])" /> + <source value="http://hl7.org/fhir/StructureDefinition/Condition" /> + </constraint> + <isSummary value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="The target of a resource reference is a RIM entry point (Act, Role, or Entity)" /> + </mapping> + <mapping> + <identity value="w5" /> + <map value="FiveWs.why[x]" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".self" /> + </mapping> + </element> + <element id="Condition.note"> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status"> + <valueCode value="normative" /> + </extension> + <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version"> + <valueCode value="4.0.0" /> + </extension> + <path value="Condition.note" /> + <short value="Additional information about the Condition" /> + <definition value="Additional information about the Condition. This is a general notes/comments entry for description of the Condition, its diagnosis and prognosis." /> + <comment value="For systems that do not have structured annotations, they can simply communicate a single annotation with no author or time. This element may need to be included in narrative because of the potential for modifying information. *Annotations SHOULD NOT* be used to communicate "modifying" information that could be computable. (This is a SHOULD because enforcing user behavior is nearly impossible)." /> + <min value="0" /> + <max value="*" /> + <base> + <path value="Condition.note" /> + <min value="0" /> + <max value="*" /> + </base> + <type> + <code value="Annotation" /> + </type> + <condition value="ele-1" /> + <constraint> + <key value="ele-1" /> + <severity value="error" /> + <human value="All FHIR elements must have a @value or children" /> + <expression value="hasValue() or (children().count() > id.count())" /> + <xpath value="@value|f:*|h:div" /> + <source value="http://hl7.org/fhir/StructureDefinition/Element" /> + </constraint> + <mustSupport value="true" /> + <mapping> + <identity value="rim" /> + <map value="n/a" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="N/A" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value="Act" /> + </mapping> + <mapping> + <identity value="workflow" /> + <map value="Event.note" /> + </mapping> + <mapping> + <identity value="v2" /> + <map value="NTE child of PRB" /> + </mapping> + <mapping> + <identity value="rim" /> + <map value=".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code="annotation"].value" /> + </mapping> + </element> + </snapshot> + <differential> + <element id="Condition.category"> + <path value="Condition.category" /> + <min value="1" /> + <mustSupport value="true" /> + </element> + <element id="Condition.category.coding"> + <path value="Condition.category.coding" /> + <slicing> + <discriminator> + <type value="pattern" /> + <path value="$this" /> + </discriminator> + <rules value="open" /> + </slicing> + <min value="1" /> + <mustSupport value="true" /> + </element> + <element id="Condition.category.coding:symptoms"> + <path value="Condition.category.coding" /> + <sliceName value="symptoms" /> + <min value="1" /> + <max value="1" /> + <patternCoding> + <system value="http://loinc.org" /> + <code value="75325-1" /> + </patternCoding> + <mustSupport value="true" /> + </element> + <element id="Condition.category.coding:symptoms.system"> + <path value="Condition.category.coding.system" /> + <min value="1" /> + <mustSupport value="true" /> + </element> + <element id="Condition.category.coding:symptoms.code"> + <path value="Condition.category.coding.code" /> + <min value="1" /> + <mustSupport value="true" /> + </element> + <element id="Condition.severity"> + <path value="Condition.severity" /> + <mustSupport value="true" /> + <binding> + <strength value="preferred" /> + <valueSet value="https://www.netzwerk-universitaetsmedizin.de/fhir/ValueSet/condition-severity" /> + </binding> + </element> + <element id="Condition.code.coding:sct"> + <path value="Condition.code.coding" /> + <sliceName value="sct" /> + <min value="1" /> + <binding> + <strength value="required" /> + <valueSet value="https://www.netzwerk-universitaetsmedizin.de/fhir/ValueSet/sars-cov-2-symptoms" /> + </binding> + </element> + <element id="Condition.code.coding:orphanet"> + <path value="Condition.code.coding" /> + <sliceName value="orphanet" /> + <max value="0" /> + </element> + <element id="Condition.onset[x]:onsetPeriod"> + <path value="Condition.onset[x]" /> + <sliceName value="onsetPeriod" /> + </element> + <element id="Condition.onset[x]:onsetPeriod.extension"> + <path value="Condition.onset[x].extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <rules value="open" /> + </slicing> + </element> + <element id="Condition.onset[x]:onsetPeriod.extension:dataAbsentReason"> + <path value="Condition.onset[x].extension" /> + <sliceName value="dataAbsentReason" /> + <type> + <code value="Extension" /> + <profile value="http://hl7.org/fhir/StructureDefinition/data-absent-reason" /> + </type> + </element> + <element id="Condition.onset[x]:onsetDateTime"> + <path value="Condition.onset[x]" /> + <sliceName value="onsetDateTime" /> + </element> + <element id="Condition.onset[x]:onsetDateTime.extension"> + <path value="Condition.onset[x].extension" /> + <slicing> + <discriminator> + <type value="value" /> + <path value="url" /> + </discriminator> + <rules value="open" /> + </slicing> + </element> + <element id="Condition.onset[x]:onsetDateTime.extension:dataAbsentReason"> + <path value="Condition.onset[x].extension" /> + <sliceName value="dataAbsentReason" /> + <type> + <code value="Extension" /> + <profile value="http://hl7.org/fhir/StructureDefinition/data-absent-reason" /> + </type> + </element> + </differential> </StructureDefinition> \ No newline at end of file From fa2f9e817ce8f3d05db8bc51c22cd56d40d4345b Mon Sep 17 00:00:00 2001 From: Renaud Subiger <renaud@subiger.com> Date: Wed, 15 Sep 2021 17:24:23 +0200 Subject: [PATCH 2/2] Fix tests --- .../fhirbridge/fhir/condition/SymptomIT.java | 2 + .../create-symptoms-covid-19-unknown.json | 14 --- ...agon-create-symptoms-covid-19-unknown.json | 104 +++++++++--------- 3 files changed, 51 insertions(+), 69 deletions(-) diff --git a/src/test/java/org/ehrbase/fhirbridge/fhir/condition/SymptomIT.java b/src/test/java/org/ehrbase/fhirbridge/fhir/condition/SymptomIT.java index 991246e53..ffdf0aff4 100644 --- a/src/test/java/org/ehrbase/fhirbridge/fhir/condition/SymptomIT.java +++ b/src/test/java/org/ehrbase/fhirbridge/fhir/condition/SymptomIT.java @@ -4,6 +4,7 @@ import org.ehrbase.fhirbridge.ehr.converter.specific.symptom.SymptomCompositionConverter; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.SymptomComposition; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.AusgeschlossenesSymptomEvaluation; +import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.UnbekanntesSymptomAussageUeberDieFehlendeInformationElement; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.UnbekanntesSymptomEvaluation; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.VorliegendesSymptomAnatomischeLokalisationElement; import org.ehrbase.fhirbridge.ehr.opt.symptomcomposition.definition.VorliegendesSymptomObservation; @@ -58,6 +59,7 @@ public Javers getJavers() { .registerValueObject(AusgeschlossenesSymptomEvaluation.class) .registerValueObject(UnbekanntesSymptomEvaluation.class) .registerValueObject(VorliegendesSymptomAnatomischeLokalisationElement.class) + .registerValueObject(UnbekanntesSymptomAussageUeberDieFehlendeInformationElement.class) .build(); } diff --git a/src/test/resources/Condition/Symptom/create-symptoms-covid-19-unknown.json b/src/test/resources/Condition/Symptom/create-symptoms-covid-19-unknown.json index 75eadd3ac..520348eb9 100644 --- a/src/test/resources/Condition/Symptom/create-symptoms-covid-19-unknown.json +++ b/src/test/resources/Condition/Symptom/create-symptoms-covid-19-unknown.json @@ -48,19 +48,5 @@ "system": "urn:ietf:rfc:4122", "value": "{{patientId}}" } - }, - "verificationStatus": { - "coding": [ - { - "code": "confirmed", - "display": "Confirmed", - "system": "http://terminology.hl7.org/CodeSystem/condition-ver-status" - }, - { - "code": "410605003", - "display": "Confirmed present (qualifier value)", - "system": "http://snomed.info/sct" - } - ] } } \ No newline at end of file diff --git a/src/test/resources/Condition/Symptom/paragon-create-symptoms-covid-19-unknown.json b/src/test/resources/Condition/Symptom/paragon-create-symptoms-covid-19-unknown.json index 49cbd2cc1..47271f934 100644 --- a/src/test/resources/Condition/Symptom/paragon-create-symptoms-covid-19-unknown.json +++ b/src/test/resources/Condition/Symptom/paragon-create-symptoms-covid-19-unknown.json @@ -17,7 +17,7 @@ "_type" : "FEEDER_AUDIT", "originating_system_item_ids" : [ { "_type" : "DV_IDENTIFIER", - "id" : "Condition/c8537710-3260-44d6-8a6f-e4d664f64cd8/_history/1", + "id" : "Condition/a0c226ac-9c96-40b6-80cb-f3ae6b1f1de4/_history/1", "type" : "fhir_logical_id" } ], "originating_system_audit" : { @@ -88,7 +88,7 @@ }, "value" : { "_type" : "DV_CODED_TEXT", - "value" : "75325-1", + "value" : "Symptom", "defining_code" : { "_type" : "CODE_PHRASE", "terminology_id" : { @@ -104,10 +104,19 @@ } }, "content" : [ { - "_type" : "OBSERVATION", + "_type" : "EVALUATION", "name" : { "_type" : "DV_TEXT", - "value" : "Vorliegendes Symptom" + "value" : "Unbekanntes Symptom" + }, + "archetype_details" : { + "archetype_id" : { + "value" : "openEHR-EHR-EVALUATION.absence.v2" + }, + "template_id" : { + "value" : "Symptom" + }, + "rm_version" : "1.0.4" }, "language" : { "_type" : "CODE_PHRASE", @@ -129,68 +138,53 @@ "_type" : "PARTY_SELF" }, "data" : { + "_type" : "ITEM_TREE", "name" : { "_type" : "DV_TEXT", - "value" : "Event Series" - }, - "origin" : { - "_type" : "DV_DATE_TIME", - "value" : "2020-10-05T00:00:00+02:00" + "value" : "Baum" }, - "events" : [ { - "_type" : "POINT_EVENT", + "items" : [ { + "_type" : "ELEMENT", "name" : { "_type" : "DV_TEXT", - "value" : "*Any event(en)" + "value" : "Unbekanntes Symptom" }, - "time" : { - "_type" : "DV_DATE_TIME", - "value" : "2020-10-05T00:00:00+02:00" - }, - "data" : { - "_type" : "ITEM_TREE", - "name" : { - "_type" : "DV_TEXT", - "value" : "Tree" - }, - "items" : [ { - "_type" : "ELEMENT", - "name" : { - "_type" : "DV_TEXT", - "value" : "Name des Symptoms/Krankheitsanzeichens" - }, - "value" : { - "_type" : "DV_CODED_TEXT", - "value" : "36955009", - "defining_code" : { - "_type" : "CODE_PHRASE", - "terminology_id" : { - "_type" : "TERMINOLOGY_ID", - "value" : "SNOMED Clinical Terms" - }, - "code_string" : "36955009" - } - }, - "archetype_node_id" : "at0001" - }, { - "_type" : "ELEMENT", - "name" : { - "_type" : "DV_TEXT", - "value" : "Beginn der Episode" + "value" : { + "_type" : "DV_CODED_TEXT", + "value" : "Loss of taste (finding)", + "defining_code" : { + "_type" : "CODE_PHRASE", + "terminology_id" : { + "_type" : "TERMINOLOGY_ID", + "value" : "SNOMED Clinical Terms" }, - "value" : { - "_type" : "DV_DATE_TIME", - "value" : "2020-10-05T00:00:00+02:00" + "code_string" : "36955009" + } + }, + "archetype_node_id" : "at0002" + }, { + "_type" : "ELEMENT", + "name" : { + "_type" : "DV_TEXT", + "value" : "Aussage über die fehlende Information" + }, + "value" : { + "_type" : "DV_CODED_TEXT", + "value" : "Unknown (qualifier value)", + "defining_code" : { + "_type" : "CODE_PHRASE", + "terminology_id" : { + "_type" : "TERMINOLOGY_ID", + "value" : "SNOMED Clinical Terms" }, - "archetype_node_id" : "at0152" - } ], - "archetype_node_id" : "at0192" + "code_string" : "261665006" + } }, - "archetype_node_id" : "at0191" + "archetype_node_id" : "at0005" } ], - "archetype_node_id" : "at0190" + "archetype_node_id" : "at0001" }, - "archetype_node_id" : "openEHR-EHR-OBSERVATION.symptom_sign.v0" + "archetype_node_id" : "openEHR-EHR-EVALUATION.absence.v2" } ], "archetype_node_id" : "openEHR-EHR-COMPOSITION.registereintrag.v1" } \ No newline at end of file